mono_realloc_native_code (struct MonoCompile * cfg)
{
  void * D.26683;
  unsigned int D.26684;
  unsigned char * D.26685;

  D.26684 = cfg->code_size;
  D.26685 = cfg->native_code;
  D.26683 = monoeg_realloc (D.26685, D.26684);
  return D.26683;
}


mono_running_on_valgrind ()
{
  volatile unsigned int D.24586;
  gboolean D.26689;

  {
    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__("roll $3,  %%edi ; roll $13, %%edi
	roll $29, %%edi ; roll $19, %%edi
	xchgl %%ebx,%%ebx" : "=d" _zzq_result : "a" &_zzq_args[0], "0" 0 : "memory", "cc");
    D.24586 = _zzq_result;
  }
  if (D.24586 != 0) goto <D.26687>; else goto <D.26688>;
  <D.26687>:
  D.26689 = 1;
  return D.26689;
  <D.26688>:
  D.26689 = 0;
  return D.26689;
}


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

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


get_method_from_ip (void * ip)
{
  union mono_mutex_t * D.26697;
  _Bool D.26700;
  long int D.26701;
  long int D.26702;
  void * D.26705;
  struct GHashTable * D.26706;
  _Bool D.26709;
  long int D.26710;
  long int D.26711;
  struct MonoMethod * D.26714;
  char * D.26717;
  struct MonoMethod * D.26718;
  int ip.0;
  void * D.26720;
  int D.26721;
  int D.26722;
  unsigned int D.26723;
  struct MonoMethod * D.26724;
  char * D.26725;
  int D.26726;
  sizetype D.26727;
  char * D.26728;
  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.26693>; else goto <D.26694>;
      <D.26693>:
      domain = mono_get_root_domain ();
      <D.26694>:
      ji = mono_jit_info_table_find (domain, ip);
      if (ji == 0B) goto <D.26695>; else goto <D.26696>;
      <D.26695>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

        D.26697 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.26697);
        if (ret != 0) goto <D.26698>; else goto <D.26699>;
        <D.26698>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26699>:
        D.26700 = ret != 0;
        D.26701 = (long int) D.26700;
        D.26702 = __builtin_expect (D.26701, 0);
        if (D.26702 != 0) goto <D.26703>; else goto <D.26704>;
        <D.26703>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 305, "ret == 0");
        <D.26704>:
      }
      D.26705 = domain->runtime_info;
      D.26706 = MEM[(struct MonoJitDomainInfo *)D.26705].jit_trampoline_hash;
      monoeg_g_hash_table_foreach (D.26706, find_tramp, &user_data);
      {
        int ret;

        D.26697 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.26697);
        if (ret != 0) goto <D.26707>; else goto <D.26708>;
        <D.26707>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26708>:
        D.26709 = ret != 0;
        D.26710 = (long int) D.26709;
        D.26711 = __builtin_expect (D.26710, 0);
        if (D.26711 != 0) goto <D.26712>; else goto <D.26713>;
        <D.26712>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 307, "ret == 0");
        <D.26713>:
      }
      D.26714 = user_data.method;
      if (D.26714 != 0B) goto <D.26715>; else goto <D.26716>;
      <D.26715>:
      {
        char * mname;

        D.26714 = user_data.method;
        mname = mono_method_full_name (D.26714, 1);
        res = monoeg_g_strdup_printf ("<%p - JIT trampoline for %s>", ip, mname);
        monoeg_g_free (mname);
        D.26717 = res;
        return D.26717;
      }
      <D.26716>:
      D.26717 = 0B;
      return D.26717;
      <D.26696>:
      D.26718 = jinfo_get_method (ji);
      method = mono_method_full_name (D.26718, 1);
      ip.0 = (int) ip;
      D.26720 = ji->code_start;
      D.26721 = (int) D.26720;
      D.26722 = ip.0 - D.26721;
      D.26723 = (unsigned int) D.26722;
      D.26724 = jinfo_get_method (ji);
      location = mono_debug_lookup_source_location (D.26724, D.26723, domain);
      D.26725 = domain->friendly_name;
      D.26720 = ji->code_start;
      D.26726 = ji->code_size;
      D.26727 = (sizetype) D.26726;
      D.26728 = D.26720 + D.26727;
      D.26720 = ji->code_start;
      ip.0 = (int) ip;
      D.26720 = ji->code_start;
      D.26721 = (int) D.26720;
      D.26722 = ip.0 - D.26721;
      res = monoeg_g_strdup_printf (" %s + 0x%x (%p %p) [%p - %s]", method, D.26722, D.26720, D.26728, domain, D.26725);
      mono_debug_free_source_location (location);
      monoeg_g_free (method);
      D.26717 = res;
      return D.26717;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


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

  ud = user_data;
  D.26731 = ud->ip;
  if (D.26731 == value) goto <D.26732>; else goto <D.26733>;
  <D.26732>:
  ud->method = key;
  <D.26733>:
}


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

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


mono_print_method_from_ip (void * ip)
{
  struct MonoDomain * target_domain.1;
  union mono_mutex_t * D.26739;
  _Bool D.26742;
  long int D.26743;
  long int D.26744;
  void * D.26747;
  struct GHashTable * D.26748;
  _Bool D.26751;
  long int D.26752;
  long int D.26753;
  struct MonoMethod * D.26756;
  guint8 * D.26759;
  unsigned int D.26762;
  guint8 * D.26763;
  char * D.26766;
  int ip.2;
  int D.26768;
  int D.26769;
  struct _IO_FILE * stdout.3;
  struct MonoMethod * D.26771;
  struct MonoDomain * target_domain.4;
  void * D.26773;
  int D.26774;
  int D.26775;
  unsigned int D.26776;
  struct MonoMethod * D.26777;
  gboolean * D.26783;
  gboolean * D.26785;
  char * D.26786;
  int D.26787;
  sizetype D.26788;
  char * D.26789;
  unsigned int D.26792;
  char * D.26793;
  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.26737>; else goto <D.26738>;
      <D.26737>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

        D.26739 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.26739);
        if (ret != 0) goto <D.26740>; else goto <D.26741>;
        <D.26740>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26741>:
        D.26742 = ret != 0;
        D.26743 = (long int) D.26742;
        D.26744 = __builtin_expect (D.26743, 0);
        if (D.26744 != 0) goto <D.26745>; else goto <D.26746>;
        <D.26745>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 379, "ret == 0");
        <D.26746>:
      }
      D.26747 = domain->runtime_info;
      D.26748 = MEM[(struct MonoJitDomainInfo *)D.26747].jit_trampoline_hash;
      monoeg_g_hash_table_foreach (D.26748, find_tramp, &user_data);
      {
        int ret;

        D.26739 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.26739);
        if (ret != 0) goto <D.26749>; else goto <D.26750>;
        <D.26749>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26750>:
        D.26751 = ret != 0;
        D.26752 = (long int) D.26751;
        D.26753 = __builtin_expect (D.26752, 0);
        if (D.26753 != 0) goto <D.26754>; else goto <D.26755>;
        <D.26754>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 381, "ret == 0");
        <D.26755>:
      }
      D.26756 = user_data.method;
      if (D.26756 != 0B) goto <D.26757>; else goto <D.26758>;
      <D.26757>:
      {
        char * mname;

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

        tinfo = l->data;
        D.26759 = tinfo->code;
        if (D.26759 <= ip) goto <D.26760>; else goto <D.26761>;
        <D.26760>:
        D.26759 = tinfo->code;
        D.26762 = tinfo->code_size;
        D.26763 = D.26759 + D.26762;
        if (D.26763 >= ip) goto <D.26764>; else goto <D.26765>;
        <D.26764>:
        D.26766 = tinfo->name;
        ip.2 = (int) ip;
        D.26759 = tinfo->code;
        D.26768 = (int) D.26759;
        D.26769 = ip.2 - D.26768;
        printf ("IP %p is at offset 0x%x of trampoline \'%s\'.\n", ip, D.26769, D.26766);
        return;
        <D.26765>:
        <D.26761>:
      }
      l = l->next;
      <D.24634>:
      if (l != 0B) goto <D.24633>; else goto <D.24635>;
      <D.24635>:
      monoeg_g_print ("No method at %p\n", ip);
      stdout.3 = stdout;
      fflush (stdout.3);
      return;
      <D.26738>:
      D.26771 = jinfo_get_method (ji);
      method = mono_method_full_name (D.26771, 1);
      target_domain.4 = target_domain;
      ip.2 = (int) ip;
      D.26773 = ji->code_start;
      D.26774 = (int) D.26773;
      D.26775 = ip.2 - D.26774;
      D.26776 = (unsigned int) D.26775;
      D.26777 = jinfo_get_method (ji);
      source = mono_debug_lookup_source_location (D.26777, D.26776, target_domain.4);
      gsctx = mono_jit_info_get_generic_sharing_context (ji);
      shared_type = "";
      if (gsctx != 0B) goto <D.26778>; else goto <D.26779>;
      <D.26778>:
      D.26783 = gsctx->var_is_vt;
      if (D.26783 != 0B) goto <D.26780>; else goto <D.26784>;
      <D.26784>:
      D.26785 = gsctx->mvar_is_vt;
      if (D.26785 != 0B) goto <D.26780>; else goto <D.26781>;
      <D.26780>:
      shared_type = "gsharedvt ";
      goto <D.26782>;
      <D.26781>:
      shared_type = "gshared ";
      <D.26782>:
      <D.26779>:
      target_domain.4 = target_domain;
      D.26786 = target_domain.4->friendly_name;
      target_domain.4 = target_domain;
      D.26773 = ji->code_start;
      D.26787 = ji->code_size;
      D.26788 = (sizetype) D.26787;
      D.26789 = D.26773 + D.26788;
      D.26773 = ji->code_start;
      ip.2 = (int) ip;
      D.26773 = ji->code_start;
      D.26774 = (int) D.26773;
      D.26775 = ip.2 - D.26774;
      monoeg_g_print ("IP %p at offset 0x%x of %smethod %s (%p %p)[domain %p - %s]\n", ip, D.26775, shared_type, method, D.26773, D.26789, target_domain.4, D.26786);
      if (source != 0B) goto <D.26790>; else goto <D.26791>;
      <D.26790>:
      D.26792 = source->row;
      D.26793 = source->source_file;
      monoeg_g_print ("%s:%d\n", D.26793, D.26792);
      <D.26791>:
      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.26797;

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


mono_method_same_domain (struct MonoJitInfo * caller, struct MonoJitInfo * callee)
{
  _Bool D.26799;
  _Bool D.26800;
  _Bool D.26801;
  gboolean D.26804;
  unsigned char D.26805;
  unsigned char D.26806;
  unsigned char D.26809;
  unsigned char D.26810;
  struct MonoClass * D.26813;
  struct MonoClass * D.26814;
  const char * D.26817;
  char * D.26818;
  struct MonoMethod * cmethod;

  D.26799 = caller == 0B;
  D.26800 = callee == 0B;
  D.26801 = D.26799 | D.26800;
  if (D.26801 != 0) goto <D.26802>; else goto <D.26803>;
  <D.26802>:
  D.26804 = 0;
  return D.26804;
  <D.26803>:
  D.26805 = BIT_FIELD_REF <*caller, 8, 168>;
  D.26806 = D.26805 & 128;
  if (D.26806 != 0) goto <D.26807>; else goto <D.26808>;
  <D.26807>:
  D.26809 = BIT_FIELD_REF <*callee, 8, 168>;
  D.26810 = D.26809 & 128;
  if (D.26810 == 0) goto <D.26811>; else goto <D.26812>;
  <D.26811>:
  D.26804 = 0;
  return D.26804;
  <D.26812>:
  <D.26808>:
  cmethod = jinfo_get_method (caller);
  D.26813 = cmethod->klass;
  D.26814 = mono_defaults.appdomain_class;
  if (D.26813 == D.26814) goto <D.26815>; else goto <D.26816>;
  <D.26815>:
  D.26817 = cmethod->name;
  D.26818 = strstr (D.26817, "InvokeInDomain");
  if (D.26818 != 0B) goto <D.26819>; else goto <D.26820>;
  <D.26819>:
  D.26804 = 0;
  return D.26804;
  <D.26820>:
  <D.26816>:
  D.26804 = 1;
  return D.26804;
}


mono_global_codeman_reserve (int size)
{
  int mono_aot_only.5;
  struct MonoCodeManager * global_codeman.6;
  struct MonoCodeManager * global_codeman.7;
  void * D.26829;
  _Bool D.26832;
  long int D.26833;
  long int D.26834;
  _Bool D.26839;
  long int D.26840;
  long int D.26841;
  void * ptr;

  mono_aot_only.5 = mono_aot_only;
  if (mono_aot_only.5 != 0) goto <D.26823>; else goto <D.26824>;
  <D.26823>:
  monoeg_g_log (0B, 4, "Attempting to allocate from the global code manager while running with --aot-only.\n");
  <D.24645>:
  goto <D.24645>;
  <D.26824>:
  global_codeman.6 = global_codeman;
  if (global_codeman.6 == 0B) goto <D.26826>; else goto <D.26827>;
  <D.26826>:
  global_codeman.7 = mono_code_manager_new ();
  global_codeman = global_codeman.7;
  global_codeman.6 = global_codeman;
  D.26829 = mono_code_manager_reserve (global_codeman.6, size);
  return D.26829;
  <D.26827>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.26830>; else goto <D.26831>;
    <D.26830>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.26831>:
    D.26832 = ret != 0;
    D.26833 = (long int) D.26832;
    D.26834 = __builtin_expect (D.26833, 0);
    if (D.26834 != 0) goto <D.26835>; else goto <D.26836>;
    <D.26835>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 471, "ret == 0");
    <D.26836>:
  }
  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.26837>; else goto <D.26838>;
    <D.26837>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26838>:
    D.26839 = ret != 0;
    D.26840 = (long int) D.26839;
    D.26841 = __builtin_expect (D.26840, 0);
    if (D.26841 != 0) goto <D.26842>; else goto <D.26843>;
    <D.26842>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 473, "ret == 0");
    <D.26843>:
  }
  D.26829 = ptr;
  return D.26829;
}


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

  D.26845 = data;
  return D.26845;
}


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.26847;
  short unsigned int D.26848;
  unsigned int when.8;
  struct MonoUnwindOp * D.26850;
  struct MonoUnwindOp * op;

  op = monoeg_malloc0 (12);
  D.26847 = (unsigned char) tag;
  op->op = D.26847;
  D.26848 = (short unsigned int) reg;
  op->reg = D.26848;
  op->val = val;
  when.8 = (unsigned int) when;
  op->when = when.8;
  D.26850 = op;
  return D.26850;
}


mono_emit_unwind_op (struct MonoCompile * cfg, int when, int tag, int reg, int val)
{
  struct MonoMemPool * D.26852;
  unsigned char D.26853;
  short unsigned int D.26854;
  unsigned int when.9;
  struct GSList * D.26856;
  struct GSList * D.26857;
  unsigned int D.26858;
  const char * D.26861;
  const char * D.26862;
  int D.26863;
  const char * D.26864;
  struct MonoUnwindOp * op;

  D.26852 = cfg->mempool;
  op = mono_mempool_alloc0 (D.26852, 12);
  D.26853 = (unsigned char) tag;
  op->op = D.26853;
  D.26854 = (short unsigned int) reg;
  op->reg = D.26854;
  op->val = val;
  when.9 = (unsigned int) when;
  op->when = when.9;
  D.26856 = cfg->unwind_ops;
  D.26852 = cfg->mempool;
  D.26857 = g_slist_append_mempool (D.26852, D.26856, op);
  cfg->unwind_ops = D.26857;
  D.26858 = cfg->verbose_level;
  if (D.26858 > 1) goto <D.26859>; else goto <D.26860>;
  <D.26859>:
  switch (tag) <default: <D.26865>, case 12: <D.24676>, case 13: <D.24678>, case 14: <D.24679>, case 128: <D.24680>>
  <D.24676>:
  D.26861 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa: %s+0x%x\n", when, D.26861, val);
  goto <D.24677>;
  <D.24678>:
  D.26862 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa_reg: %s\n", when, D.26862);
  goto <D.24677>;
  <D.24679>:
  printf ("CFA: [%x] def_cfa_offset: 0x%x\n", when, val);
  goto <D.24677>;
  <D.24680>:
  D.26863 = -val;
  D.26864 = mono_arch_regname (reg);
  printf ("CFA: [%x] offset: %s at cfa-0x%x\n", when, D.26864, D.26863);
  goto <D.24677>;
  <D.26865>:
  <D.24677>:
  <D.26860>:
}


g_slist_append_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.26868;
  struct GSList * D.26869;
  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.26866>; else goto <D.26867>;
  <D.26866>:
  last = list;
  goto <D.13819>;
  <D.13818>:
  last = last->next;
  <D.13819>:
  D.26868 = last->next;
  if (D.26868 != 0B) goto <D.13818>; else goto <D.13820>;
  <D.13820>:
  last->next = new_list;
  D.26869 = list;
  return D.26869;
  <D.26867>:
  D.26869 = new_list;
  return D.26869;
}


mono_jump_info_token_new2 (struct MonoMemPool * mp, struct MonoImage * image, guint32 token, struct MonoGenericContext * context)
{
  _Bool D.26871;
  int D.26872;
  struct MonoGenericContext * D.26875;
  struct MonoJumpInfoToken * D.26876;
  struct MonoJumpInfoToken * res;

  res = mono_mempool_alloc0 (mp, 20);
  res->image = image;
  res->token = token;
  D.26871 = context != 0B;
  D.26872 = (int) D.26871;
  res->has_context = D.26872;
  if (context != 0B) goto <D.26873>; else goto <D.26874>;
  <D.26873>:
  D.26875 = &res->context;
  memcpy (D.26875, context, 8);
  <D.26874>:
  D.26876 = res;
  return D.26876;
}


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

  D.26879 = __builtin_object_size (__dest, 0);
  D.26878 = __builtin___memcpy_chk (__dest, __src, __len, D.26879);
  return D.26878;
}


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

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


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

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


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

  if (str != 0B) goto <D.26886>; else goto <D.26887>;
  <D.26886>:
  D.26888 = __strdup (str);
  return D.26888;
  <D.26887>:
  D.26888 = 0B;
  return D.26888;
}


mono_tramp_info_free (struct MonoTrampInfo * info)
{
  char * D.26890;
  void * D.26891;
  struct GSList * D.26892;
  struct GSList * l;

  D.26890 = info->name;
  monoeg_g_free (D.26890);
  l = info->unwind_ops;
  goto <D.24706>;
  <D.24705>:
  D.26891 = l->data;
  monoeg_g_free (D.26891);
  l = l->next;
  <D.24706>:
  if (l != 0B) goto <D.24705>; else goto <D.24707>;
  <D.24707>:
  D.26892 = info->unwind_ops;
  monoeg_g_slist_free (D.26892);
  monoeg_g_free (info);
}


mono_tramp_info_register (struct MonoTrampInfo * info)
{
  guint8 * D.26895;
  unsigned int D.26896;
  char * D.26897;
  gchar * D.26898;
  _Bool D.26901;
  long int D.26902;
  long int D.26903;
  struct GSList * tramp_infos.10;
  struct GSList * tramp_infos.11;
  _Bool D.26910;
  long int D.26911;
  long int D.26912;
  int D.26915;
  int D.26918;
  struct MonoTrampInfo * copy;

  if (info == 0B) goto <D.26893>; else goto <D.26894>;
  <D.26893>:
  return;
  <D.26894>:
  copy = monoeg_malloc0 (28);
  D.26895 = info->code;
  copy->code = D.26895;
  D.26896 = info->code_size;
  copy->code_size = D.26896;
  D.26897 = info->name;
  D.26898 = monoeg_strdup (D.26897);
  copy->name = D.26898;
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.26899>; else goto <D.26900>;
    <D.26899>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.26900>:
    D.26901 = ret != 0;
    D.26902 = (long int) D.26901;
    D.26903 = __builtin_expect (D.26902, 0);
    if (D.26903 != 0) goto <D.26904>; else goto <D.26905>;
    <D.26904>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 673, "ret == 0");
    <D.26905>:
  }
  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.26908>; else goto <D.26909>;
    <D.26908>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26909>:
    D.26910 = ret != 0;
    D.26911 = (long int) D.26910;
    D.26912 = __builtin_expect (D.26911, 0);
    if (D.26912 != 0) goto <D.26913>; else goto <D.26914>;
    <D.26913>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 675, "ret == 0");
    <D.26914>:
  }
  mono_save_trampoline_xdebug_info (info);
  D.26915 = mono_jit_map_is_enabled ();
  if (D.26915 != 0) goto <D.26916>; else goto <D.26917>;
  <D.26916>:
  D.26897 = info->name;
  D.26896 = info->code_size;
  D.26918 = (int) D.26896;
  D.26895 = info->code;
  mono_emit_jit_tramp (D.26895, D.26918, D.26897);
  <D.26917>:
  mono_tramp_info_free (info);
}


mono_debug_count ()
{
  int count.12;
  int count.13;
  const gchar * D.26922;
  gboolean D.26925;
  const gchar * D.26926;
  int D.26927;
  const gchar * D.26930;
  int D.26931;
  static int count = 0;

  count.12 = count;
  count.13 = count.12 + 1;
  count = count.13;
  D.26922 = monoeg_g_getenv ("COUNT");
  if (D.26922 == 0B) goto <D.26923>; else goto <D.26924>;
  <D.26923>:
  D.26925 = 1;
  return D.26925;
  <D.26924>:
  D.26926 = monoeg_g_getenv ("COUNT");
  D.26927 = atoi (D.26926);
  count.12 = count;
  if (D.26927 == count.12) goto <D.26928>; else goto <D.26929>;
  <D.26928>:
  break_count ();
  <D.26929>:
  D.26930 = monoeg_g_getenv ("COUNT");
  D.26931 = atoi (D.26930);
  count.12 = count;
  if (D.26931 < count.12) goto <D.26932>; else goto <D.26933>;
  <D.26932>:
  D.26925 = 0;
  return D.26925;
  <D.26933>:
  D.26925 = 1;
  return D.26925;
}


break_count ()
{

}


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

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


mono_unlink_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * from, struct MonoBasicBlock * to)
{
  struct MonoBasicBlock * * D.26937;
  unsigned int i.14;
  unsigned int D.26939;
  struct MonoBasicBlock * * D.26940;
  struct MonoBasicBlock * D.26941;
  short int D.26944;
  int D.26945;
  int pos.15;
  unsigned int pos.16;
  unsigned int D.26952;
  struct MonoBasicBlock * * D.26953;
  int D.26954;
  _Bool D.26955;
  long int D.26956;
  long int D.26957;
  short int D.26960;
  unsigned short D.26961;
  unsigned short D.26962;
  short int D.26963;
  struct MonoBasicBlock * * D.26964;
  struct MonoBasicBlock * * D.26965;
  struct MonoBasicBlock * D.26966;
  short int D.26969;
  int D.26970;
  int pos.17;
  unsigned int pos.18;
  unsigned int D.26977;
  struct MonoBasicBlock * * D.26978;
  int D.26979;
  _Bool D.26980;
  long int D.26981;
  long int D.26982;
  short int D.26985;
  unsigned short D.26986;
  unsigned short D.26987;
  short int D.26988;
  int i;
  int pos;
  gboolean found;

  found = 0;
  i = 0;
  goto <D.24731>;
  <D.24730>:
  D.26937 = from->out_bb;
  i.14 = (unsigned int) i;
  D.26939 = i.14 * 4;
  D.26940 = D.26937 + D.26939;
  D.26941 = *D.26940;
  if (D.26941 == to) goto <D.26942>; else goto <D.26943>;
  <D.26942>:
  found = 1;
  goto <D.24729>;
  <D.26943>:
  i = i + 1;
  <D.24731>:
  D.26944 = from->out_count;
  D.26945 = (int) D.26944;
  if (D.26945 > i) goto <D.24730>; else goto <D.24729>;
  <D.24729>:
  if (found != 0) goto <D.26946>; else goto <D.26947>;
  <D.26946>:
  pos = 0;
  i = 0;
  goto <D.24733>;
  <D.24732>:
  D.26937 = from->out_bb;
  i.14 = (unsigned int) i;
  D.26939 = i.14 * 4;
  D.26940 = D.26937 + D.26939;
  D.26941 = *D.26940;
  if (D.26941 != to) goto <D.26948>; else goto <D.26949>;
  <D.26948>:
  D.26937 = from->out_bb;
  pos.15 = pos;
  pos = pos.15 + 1;
  pos.16 = (unsigned int) pos.15;
  D.26952 = pos.16 * 4;
  D.26953 = D.26937 + D.26952;
  D.26937 = from->out_bb;
  i.14 = (unsigned int) i;
  D.26939 = i.14 * 4;
  D.26940 = D.26937 + D.26939;
  D.26941 = *D.26940;
  *D.26953 = D.26941;
  <D.26949>:
  i = i + 1;
  <D.24733>:
  D.26944 = from->out_count;
  D.26945 = (int) D.26944;
  if (D.26945 > i) goto <D.24732>; else goto <D.24734>;
  <D.24734>:
  D.26944 = from->out_count;
  D.26945 = (int) D.26944;
  D.26954 = D.26945 + -1;
  D.26955 = D.26954 != pos;
  D.26956 = (long int) D.26955;
  D.26957 = __builtin_expect (D.26956, 0);
  if (D.26957 != 0) goto <D.26958>; else goto <D.26959>;
  <D.26958>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 744, "pos == from->out_count - 1");
  <D.26959>:
  D.26944 = from->out_count;
  D.26960 = D.26944;
  D.26961 = (unsigned short) D.26960;
  D.26962 = D.26961 + 65535;
  D.26963 = (short int) D.26962;
  from->out_count = D.26963;
  <D.26947>:
  found = 0;
  i = 0;
  goto <D.24737>;
  <D.24736>:
  D.26964 = to->in_bb;
  i.14 = (unsigned int) i;
  D.26939 = i.14 * 4;
  D.26965 = D.26964 + D.26939;
  D.26966 = *D.26965;
  if (D.26966 == from) goto <D.26967>; else goto <D.26968>;
  <D.26967>:
  found = 1;
  goto <D.24735>;
  <D.26968>:
  i = i + 1;
  <D.24737>:
  D.26969 = to->in_count;
  D.26970 = (int) D.26969;
  if (D.26970 > i) goto <D.24736>; else goto <D.24735>;
  <D.24735>:
  if (found != 0) goto <D.26971>; else goto <D.26972>;
  <D.26971>:
  pos = 0;
  i = 0;
  goto <D.24739>;
  <D.24738>:
  D.26964 = to->in_bb;
  i.14 = (unsigned int) i;
  D.26939 = i.14 * 4;
  D.26965 = D.26964 + D.26939;
  D.26966 = *D.26965;
  if (D.26966 != from) goto <D.26973>; else goto <D.26974>;
  <D.26973>:
  D.26964 = to->in_bb;
  pos.17 = pos;
  pos = pos.17 + 1;
  pos.18 = (unsigned int) pos.17;
  D.26977 = pos.18 * 4;
  D.26978 = D.26964 + D.26977;
  D.26964 = to->in_bb;
  i.14 = (unsigned int) i;
  D.26939 = i.14 * 4;
  D.26965 = D.26964 + D.26939;
  D.26966 = *D.26965;
  *D.26978 = D.26966;
  <D.26974>:
  i = i + 1;
  <D.24739>:
  D.26969 = to->in_count;
  D.26970 = (int) D.26969;
  if (D.26970 > i) goto <D.24738>; else goto <D.24740>;
  <D.24740>:
  D.26969 = to->in_count;
  D.26970 = (int) D.26969;
  D.26979 = D.26970 + -1;
  D.26980 = D.26979 != pos;
  D.26981 = (long int) D.26980;
  D.26982 = __builtin_expect (D.26981, 0);
  if (D.26982 != 0) goto <D.26983>; else goto <D.26984>;
  <D.26983>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 761, "pos == to->in_count - 1");
  <D.26984>:
  D.26969 = to->in_count;
  D.26985 = D.26969;
  D.26986 = (unsigned short) D.26985;
  D.26987 = D.26986 + 65535;
  D.26988 = (short int) D.26987;
  to->in_count = D.26988;
  <D.26972>:
}


mono_bblocks_linked (struct MonoBasicBlock * bb1, struct MonoBasicBlock * bb2)
{
  struct MonoBasicBlock * * D.26989;
  unsigned int i.19;
  unsigned int D.26991;
  struct MonoBasicBlock * * D.26992;
  struct MonoBasicBlock * D.26993;
  gboolean D.26996;
  short int D.26997;
  int D.26998;
  int i;

  i = 0;
  goto <D.24747>;
  <D.24746>:
  D.26989 = bb1->out_bb;
  i.19 = (unsigned int) i;
  D.26991 = i.19 * 4;
  D.26992 = D.26989 + D.26991;
  D.26993 = *D.26992;
  if (D.26993 == bb2) goto <D.26994>; else goto <D.26995>;
  <D.26994>:
  D.26996 = 1;
  return D.26996;
  <D.26995>:
  i = i + 1;
  <D.24747>:
  D.26997 = bb1->out_count;
  D.26998 = (int) D.26997;
  if (D.26998 > i) goto <D.24746>; else goto <D.24748>;
  <D.24748>:
  D.26996 = 0;
  return D.26996;
}


mono_get_block_region_notry (struct MonoCompile * cfg, int region)
{
  int D.27000;
  int D.27003;
  int iftmp.20;
  <unnamed-unsigned:15> D.27009;
  int D.27010;
  _Bool D.27011;
  long int D.27012;
  long int D.27013;
  struct MonoExceptionClause * D.27016;
  unsigned int clause_index.21;
  unsigned int D.27018;
  struct MonoExceptionClause * D.27019;
  unsigned int D.27020;
  int D.27021;
  int D.27022;

  D.27000 = region & 240;
  if (D.27000 == 0) goto <D.27001>; else goto <D.27002>;
  <D.27001>:
  {
    struct MonoMethodHeader * header;
    int clause_index;

    header = cfg->header;
    D.27003 = region >> 8;
    clause_index = D.27003 + -1;
    if (clause_index < 0) goto <D.27005>; else goto <D.27008>;
    <D.27008>:
    D.27009 = header->num_clauses;
    D.27010 = (int) D.27009;
    if (D.27010 <= clause_index) goto <D.27005>; else goto <D.27006>;
    <D.27005>:
    iftmp.20 = 1;
    goto <D.27007>;
    <D.27006>:
    iftmp.20 = 0;
    <D.27007>:
    D.27011 = iftmp.20 != 0;
    D.27012 = (long int) D.27011;
    D.27013 = __builtin_expect (D.27012, 0);
    if (D.27013 != 0) goto <D.27014>; else goto <D.27015>;
    <D.27014>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 826, "clause_index >= 0 && clause_index < header->num_clauses");
    <D.27015>:
    D.27016 = header->clauses;
    clause_index.21 = (unsigned int) clause_index;
    D.27018 = clause_index.21 * 24;
    D.27019 = D.27016 + D.27018;
    D.27020 = D.27019->try_offset;
    D.27021 = (int) D.27020;
    region = mono_find_block_region_notry (cfg, D.27021);
  }
  <D.27002>:
  D.27022 = region;
  return D.27022;
}


mono_find_block_region_notry (struct MonoCompile * cfg, int offset)
{
  struct MonoExceptionClause * D.27024;
  unsigned int i.22;
  unsigned int D.27026;
  unsigned int D.27027;
  unsigned int offset.23;
  unsigned int D.27031;
  unsigned int D.27034;
  int D.27037;
  int D.27038;
  int D.27039;
  unsigned int D.27040;
  unsigned int D.27041;
  unsigned int D.27042;
  unsigned int D.27045;
  unsigned int D.27046;
  unsigned int D.27051;
  unsigned int D.27054;
  unsigned int D.27055;
  <unnamed-unsigned:15> D.27056;
  int D.27057;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  int i;

  header = cfg->header;
  i = 0;
  goto <D.24757>;
  <D.24756>:
  D.27024 = header->clauses;
  i.22 = (unsigned int) i;
  D.27026 = i.22 * 24;
  clause = D.27024 + D.27026;
  D.27027 = clause->flags;
  if (D.27027 == 1) goto <D.27028>; else goto <D.27029>;
  <D.27028>:
  offset.23 = (unsigned int) offset;
  D.27031 = clause->data.filter_offset;
  if (offset.23 >= D.27031) goto <D.27032>; else goto <D.27033>;
  <D.27032>:
  offset.23 = (unsigned int) offset;
  D.27034 = clause->handler_offset;
  if (offset.23 < D.27034) goto <D.27035>; else goto <D.27036>;
  <D.27035>:
  D.27038 = i + 1;
  D.27039 = D.27038 << 8;
  D.27040 = (unsigned int) D.27039;
  D.27027 = clause->flags;
  D.27041 = D.27040 | D.27027;
  D.27042 = D.27041 | 128;
  D.27037 = (int) D.27042;
  return D.27037;
  <D.27036>:
  <D.27033>:
  <D.27029>:
  D.27034 = clause->handler_offset;
  offset.23 = (unsigned int) offset;
  if (D.27034 <= offset.23) goto <D.27043>; else goto <D.27044>;
  <D.27043>:
  offset.23 = (unsigned int) offset;
  D.27034 = clause->handler_offset;
  D.27045 = clause->handler_len;
  D.27046 = D.27034 + D.27045;
  if (offset.23 < D.27046) goto <D.27047>; else goto <D.27048>;
  <D.27047>:
  D.27027 = clause->flags;
  if (D.27027 == 2) goto <D.27049>; else goto <D.27050>;
  <D.27049>:
  D.27038 = i + 1;
  D.27039 = D.27038 << 8;
  D.27040 = (unsigned int) D.27039;
  D.27027 = clause->flags;
  D.27041 = D.27040 | D.27027;
  D.27051 = D.27041 | 16;
  D.27037 = (int) D.27051;
  return D.27037;
  <D.27050>:
  D.27027 = clause->flags;
  if (D.27027 == 4) goto <D.27052>; else goto <D.27053>;
  <D.27052>:
  D.27038 = i + 1;
  D.27039 = D.27038 << 8;
  D.27040 = (unsigned int) D.27039;
  D.27027 = clause->flags;
  D.27041 = D.27040 | D.27027;
  D.27054 = D.27041 | 64;
  D.27037 = (int) D.27054;
  return D.27037;
  <D.27053>:
  D.27038 = i + 1;
  D.27039 = D.27038 << 8;
  D.27040 = (unsigned int) D.27039;
  D.27027 = clause->flags;
  D.27041 = D.27040 | D.27027;
  D.27055 = D.27041 | 32;
  D.27037 = (int) D.27055;
  return D.27037;
  <D.27048>:
  <D.27044>:
  i = i + 1;
  <D.24757>:
  D.27056 = header->num_clauses;
  D.27057 = (int) D.27056;
  if (D.27057 > i) goto <D.24756>; else goto <D.24758>;
  <D.24758>:
  D.27037 = -1;
  return D.27037;
}


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

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


mono_reverse_branch_op (guint32 opcode)
{
  unsigned int D.27063;
  int D.27066;
  unsigned int D.27068;
  int D.27071;
  unsigned int D.27073;
  int D.27076;
  unsigned int D.27078;
  int D.27081;
  guint32 D.27083;
  static const int reverse_map[10] = {64, 63, 62, 61, 60, 59, 68, 67, 66, 65};
  static const int reverse_fmap[10] = {667, 666, 665, 664, 663, 662, 671, 670, 669, 668};
  static const int reverse_lmap[10] = {560, 559, 558, 557, 556, 555, 564, 563, 562, 561};
  static const int reverse_imap[10] = {657, 656, 655, 654, 653, 652, 661, 660, 659, 658};

  D.27063 = opcode + 4294967237;
  if (D.27063 <= 9) goto <D.27064>; else goto <D.27065>;
  <D.27064>:
  D.27063 = opcode + 4294967237;
  D.27066 = reverse_map[D.27063];
  opcode = (guint32) D.27066;
  goto <D.27067>;
  <D.27065>:
  D.27068 = opcode + 4294966634;
  if (D.27068 <= 9) goto <D.27069>; else goto <D.27070>;
  <D.27069>:
  D.27068 = opcode + 4294966634;
  D.27071 = reverse_fmap[D.27068];
  opcode = (guint32) D.27071;
  goto <D.27072>;
  <D.27070>:
  D.27073 = opcode + 4294966741;
  if (D.27073 <= 9) goto <D.27074>; else goto <D.27075>;
  <D.27074>:
  D.27073 = opcode + 4294966741;
  D.27076 = reverse_lmap[D.27073];
  opcode = (guint32) D.27076;
  goto <D.27077>;
  <D.27075>:
  D.27078 = opcode + 4294966644;
  if (D.27078 <= 9) goto <D.27079>; else goto <D.27080>;
  <D.27079>:
  D.27078 = opcode + 4294966644;
  D.27081 = reverse_imap[D.27078];
  opcode = (guint32) D.27081;
  goto <D.27082>;
  <D.27080>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 889);
  <D.27082>:
  <D.27077>:
  <D.27072>:
  <D.27067>:
  D.27083 = opcode;
  return D.27083;
}


mono_type_to_store_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  unsigned char D.27085;
  unsigned char D.27086;
  guint D.27089;
  unsigned char D.27090;
  int D.27091;
  struct MonoClass * D.27092;
  unsigned char D.27093;
  unsigned char D.27094;
  unsigned int D.27097;
  unsigned int D.27098;
  struct MonoClass * D.27101;
  unsigned char D.27102;
  unsigned char D.27103;
  struct MonoGenericClass * D.27106;
  struct MonoClass * D.27107;
  int D.27108;
  void handle_enum = <<< error >>>;

  D.27085 = BIT_FIELD_REF <*type, 8, 56>;
  D.27086 = D.27085 & 64;
  if (D.27086 != 0) goto <D.27087>; else goto <D.27088>;
  <D.27087>:
  D.27089 = 374;
  return D.27089;
  <D.27088>:
  type = mini_replace_type (type);
  handle_enum:
  D.27090 = type->type;
  D.27091 = (int) D.27090;
  switch (D.27091) <default: <D.24817>, case 2: <D.24793>, case 3: <D.24796>, case 4: <D.24791>, case 5: <D.24792>, case 6: <D.24794>, case 7: <D.24795>, case 8: <D.24797>, case 9: <D.24798>, case 10: <D.24808>, case 11: <D.24809>, case 12: <D.24810>, case 13: <D.24811>, case 14: <D.24804>, case 15: <D.24801>, case 17: <D.24812>, case 18: <D.24803>, case 19: <D.24815>, case 20: <D.24807>, case 21: <D.24814>, case 22: <D.24813>, case 24: <D.24799>, case 25: <D.24800>, case 27: <D.24802>, case 28: <D.24805>, case 29: <D.24806>, case 30: <D.24816>>
  <D.24791>:
  <D.24792>:
  <D.24793>:
  D.27089 = 375;
  return D.27089;
  <D.24794>:
  <D.24795>:
  <D.24796>:
  D.27089 = 376;
  return D.27089;
  <D.24797>:
  <D.24798>:
  D.27089 = 377;
  return D.27089;
  <D.24799>:
  <D.24800>:
  <D.24801>:
  <D.24802>:
  D.27089 = 374;
  return D.27089;
  <D.24803>:
  <D.24804>:
  <D.24805>:
  <D.24806>:
  <D.24807>:
  D.27089 = 374;
  return D.27089;
  <D.24808>:
  <D.24809>:
  D.27089 = 378;
  return D.27089;
  <D.24810>:
  D.27089 = 379;
  return D.27089;
  <D.24811>:
  D.27089 = 380;
  return D.27089;
  <D.24812>:
  D.27092 = type->data.klass;
  D.27093 = BIT_FIELD_REF <*D.27092, 8, 160>;
  D.27094 = D.27093 & 16;
  if (D.27094 != 0) goto <D.27095>; else goto <D.27096>;
  <D.27095>:
  D.27092 = type->data.klass;
  type = mono_class_enum_basetype (D.27092);
  goto handle_enum;
  <D.27096>:
  D.27097 = cfg->opt;
  D.27098 = D.27097 & 67108864;
  if (D.27098 != 0) goto <D.27099>; else goto <D.27100>;
  <D.27099>:
  D.27101 = mono_class_from_mono_type (type);
  D.27102 = BIT_FIELD_REF <*D.27101, 8, 192>;
  D.27103 = D.27102 & 2;
  if (D.27103 != 0) goto <D.27104>; else goto <D.27105>;
  <D.27104>:
  D.27089 = 389;
  return D.27089;
  <D.27105>:
  <D.27100>:
  D.27089 = 390;
  return D.27089;
  <D.24813>:
  D.27089 = 390;
  return D.27089;
  <D.24814>:
  D.27106 = type->data.generic_class;
  D.27107 = D.27106->container_class;
  type = &D.27107->byval_arg;
  goto handle_enum;
  <D.24815>:
  <D.24816>:
  D.27108 = mini_type_var_is_vt (cfg, type);
  if (D.27108 != 0) goto <D.27109>; else goto <D.27110>;
  <D.27109>:
  D.27089 = 390;
  return D.27089;
  <D.27110>:
  D.27089 = 374;
  return D.27089;
  <D.24817>:
  D.27090 = type->type;
  D.27091 = (int) D.27090;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_store_membase", D.27091);
  <D.24818>:
  goto <D.24818>;
  D.27089 = 4294967295;
  return D.27089;
}


mono_type_to_load_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  unsigned char D.27112;
  unsigned char D.27113;
  guint D.27116;
  unsigned char D.27117;
  int D.27118;
  unsigned int D.27119;
  unsigned int D.27120;
  struct MonoClass * D.27123;
  unsigned char D.27124;
  unsigned char D.27125;
  int D.27128;
  struct MonoGenericSharingContext * D.27131;
  _Bool D.27132;
  long int D.27133;
  long int D.27134;
  int D.27137;

  D.27112 = BIT_FIELD_REF <*type, 8, 56>;
  D.27113 = D.27112 & 64;
  if (D.27113 != 0) goto <D.27114>; else goto <D.27115>;
  <D.27114>:
  D.27116 = 391;
  return D.27116;
  <D.27115>:
  type = mini_replace_type (type);
  D.27117 = type->type;
  D.27118 = (int) D.27117;
  switch (D.27118) <default: <D.24849>, case 2: <D.24825>, case 3: <D.24828>, case 4: <D.24823>, case 5: <D.24824>, case 6: <D.24826>, case 7: <D.24827>, case 8: <D.24829>, case 9: <D.24830>, case 10: <D.24840>, case 11: <D.24841>, case 12: <D.24842>, case 13: <D.24843>, case 14: <D.24836>, case 15: <D.24833>, case 17: <D.24844>, case 18: <D.24835>, case 19: <D.24847>, case 20: <D.24839>, case 21: <D.24846>, case 22: <D.24845>, case 24: <D.24831>, case 25: <D.24832>, case 27: <D.24834>, case 28: <D.24837>, case 29: <D.24838>, case 30: <D.24848>>
  <D.24823>:
  D.27116 = 392;
  return D.27116;
  <D.24824>:
  <D.24825>:
  D.27116 = 393;
  return D.27116;
  <D.24826>:
  D.27116 = 394;
  return D.27116;
  <D.24827>:
  <D.24828>:
  D.27116 = 395;
  return D.27116;
  <D.24829>:
  D.27116 = 396;
  return D.27116;
  <D.24830>:
  D.27116 = 397;
  return D.27116;
  <D.24831>:
  <D.24832>:
  <D.24833>:
  <D.24834>:
  D.27116 = 391;
  return D.27116;
  <D.24835>:
  <D.24836>:
  <D.24837>:
  <D.24838>:
  <D.24839>:
  D.27116 = 391;
  return D.27116;
  <D.24840>:
  <D.24841>:
  D.27116 = 398;
  return D.27116;
  <D.24842>:
  D.27116 = 399;
  return D.27116;
  <D.24843>:
  D.27116 = 400;
  return D.27116;
  <D.24844>:
  D.27119 = cfg->opt;
  D.27120 = D.27119 & 67108864;
  if (D.27120 != 0) goto <D.27121>; else goto <D.27122>;
  <D.27121>:
  D.27123 = mono_class_from_mono_type (type);
  D.27124 = BIT_FIELD_REF <*D.27123, 8, 192>;
  D.27125 = D.27124 & 2;
  if (D.27125 != 0) goto <D.27126>; else goto <D.27127>;
  <D.27126>:
  D.27116 = 401;
  return D.27116;
  <D.27127>:
  <D.27122>:
  <D.24845>:
  D.27116 = 403;
  return D.27116;
  <D.24846>:
  D.27128 = mono_type_generic_inst_is_valuetype (type);
  if (D.27128 != 0) goto <D.27129>; else goto <D.27130>;
  <D.27129>:
  D.27116 = 403;
  return D.27116;
  <D.27130>:
  D.27116 = 391;
  return D.27116;
  <D.24847>:
  <D.24848>:
  D.27131 = cfg->generic_sharing_context;
  D.27132 = D.27131 == 0B;
  D.27133 = (long int) D.27132;
  D.27134 = __builtin_expect (D.27133, 0);
  if (D.27134 != 0) goto <D.27135>; else goto <D.27136>;
  <D.27135>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1012, "cfg->generic_sharing_context");
  <D.27136>:
  D.27137 = mini_type_var_is_vt (cfg, type);
  if (D.27137 != 0) goto <D.27138>; else goto <D.27139>;
  <D.27138>:
  D.27116 = 403;
  return D.27116;
  <D.27139>:
  D.27116 = 391;
  return D.27116;
  <D.24849>:
  D.27117 = type->type;
  D.27118 = (int) D.27117;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_load_membase", D.27118);
  <D.24850>:
  goto <D.24850>;
  D.27116 = 4294967295;
  return D.27116;
}


mini_type_to_stind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.27141;
  unsigned char D.27144;
  unsigned char D.27145;
  unsigned char D.27148;
  _Bool D.27149;
  _Bool D.27150;
  _Bool D.27151;
  int D.27154;
  guint D.27157;

  type = mini_replace_type (type);
  D.27141 = cfg->generic_sharing_context;
  if (D.27141 != 0B) goto <D.27142>; else goto <D.27143>;
  <D.27142>:
  D.27144 = BIT_FIELD_REF <*type, 8, 56>;
  D.27145 = D.27144 & 64;
  if (D.27145 == 0) goto <D.27146>; else goto <D.27147>;
  <D.27146>:
  D.27148 = type->type;
  D.27149 = D.27148 == 19;
  D.27150 = D.27148 == 30;
  D.27151 = D.27149 | D.27150;
  if (D.27151 != 0) goto <D.27152>; else goto <D.27153>;
  <D.27152>:
  D.27154 = mini_type_var_is_vt (cfg, type);
  if (D.27154 != 0) goto <D.27155>; else goto <D.27156>;
  <D.27155>:
  D.27157 = 129;
  return D.27157;
  <D.27156>:
  D.27157 = 81;
  return D.27157;
  <D.27153>:
  <D.27147>:
  <D.27143>:
  D.27157 = mono_type_to_stind (type);
  return D.27157;
}


mono_op_imm_to_op (int opcode)
{
  int D.27159;
  const char * D.27160;

  switch (opcode) <default: <D.24898>, case 323: <D.24895>, case 327: <D.24896>, case 339: <D.24897>, case 433: <D.24862>, case 436: <D.24887>, case 438: <D.24888>, case 440: <D.24868>, case 441: <D.24869>, case 442: <D.24870>, case 542: <D.24864>, case 543: <D.24866>, case 545: <D.24872>, case 546: <D.24874>, case 547: <D.24876>, case 548: <D.24878>, case 549: <D.24880>, case 550: <D.24882>, case 624: <D.24893>, case 626: <D.24894>, case 629: <D.24863>, case 630: <D.24865>, case 631: <D.24867>, case 632: <D.24883>, case 633: <D.24884>, case 634: <D.24886>, case 635: <D.24885>, case 636: <D.24871>, case 637: <D.24873>, case 638: <D.24875>, case 639: <D.24877>, case 640: <D.24879>, case 641: <D.24881>, case 756: <D.24890>, case 758: <D.24892>, case 760: <D.24889>, case 762: <D.24891>>
  <D.24862>:
  D.27159 = 569;
  return D.27159;
  <D.24863>:
  D.27159 = 569;
  return D.27159;
  <D.24864>:
  D.27159 = 483;
  return D.27159;
  <D.24865>:
  D.27159 = 570;
  return D.27159;
  <D.24866>:
  D.27159 = 484;
  return D.27159;
  <D.24867>:
  D.27159 = 571;
  return D.27159;
  <D.24868>:
  D.27159 = 576;
  return D.27159;
  <D.24869>:
  D.27159 = 577;
  return D.27159;
  <D.24870>:
  D.27159 = 578;
  return D.27159;
  <D.24871>:
  D.27159 = 576;
  return D.27159;
  <D.24872>:
  D.27159 = 490;
  return D.27159;
  <D.24873>:
  D.27159 = 577;
  return D.27159;
  <D.24874>:
  D.27159 = 491;
  return D.27159;
  <D.24875>:
  D.27159 = 578;
  return D.27159;
  <D.24876>:
  D.27159 = 492;
  return D.27159;
  <D.24877>:
  D.27159 = 579;
  return D.27159;
  <D.24878>:
  D.27159 = 493;
  return D.27159;
  <D.24879>:
  D.27159 = 580;
  return D.27159;
  <D.24880>:
  D.27159 = 494;
  return D.27159;
  <D.24881>:
  D.27159 = 581;
  return D.27159;
  <D.24882>:
  D.27159 = 495;
  return D.27159;
  <D.24883>:
  D.27159 = 572;
  return D.27159;
  <D.24884>:
  D.27159 = 573;
  return D.27159;
  <D.24885>:
  D.27159 = 575;
  return D.27159;
  <D.24886>:
  D.27159 = 574;
  return D.27159;
  <D.24887>:
  D.27159 = 572;
  return D.27159;
  <D.24888>:
  D.27159 = 574;
  return D.27159;
  <D.24889>:
  D.27159 = 759;
  return D.27159;
  <D.24890>:
  D.27159 = 755;
  return D.27159;
  <D.24891>:
  D.27159 = 761;
  return D.27159;
  <D.24892>:
  D.27159 = 757;
  return D.27159;
  <D.24893>:
  D.27159 = 623;
  return D.27159;
  <D.24894>:
  D.27159 = 625;
  return D.27159;
  <D.24895>:
  D.27159 = 322;
  return D.27159;
  <D.24896>:
  D.27159 = 326;
  return D.27159;
  <D.24897>:
  D.27159 = 338;
  return D.27159;
  <D.24898>:
  D.27160 = mono_inst_name (opcode);
  printf ("%s\n", D.27160);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 1157);
  D.27159 = -1;
  return D.27159;
}


mono_decompose_op_imm (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  struct MonoMemPool * D.27162;
  int D.27163;
  struct MonoInst * D.27164;
  int D.27165;
  int D.27166;
  const unsigned char * D.27167;
  int D.27168;
  unsigned int D.27169;
  int D.27170;
  short unsigned int D.27171;
  int D.27172;
  int D.27173;
  short unsigned int D.27174;
  int D.27177;
  unsigned int D.27179;
  unsigned int D.27180;
  unsigned int D.27181;
  struct MonoInst * temp;

  D.27162 = cfg->mempool;
  temp = mono_mempool_alloc (D.27162, 48);
  temp->data.op[1].const_val = 0;
  D.27163 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.27163;
  temp->prev = 0B;
  D.27164 = temp->prev;
  temp->next = D.27164;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.27165 = temp->sreg3;
  temp->sreg2 = D.27165;
  D.27166 = temp->sreg2;
  temp->sreg1 = D.27166;
  D.27167 = cfg->ip;
  temp->cil_code = D.27167;
  D.27168 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.27168;
  D.27169 = mono_alloc_ireg (cfg);
  D.27170 = (int) D.27169;
  temp->dreg = D.27170;
  mono_bblock_insert_before_ins (bb, ins, temp);
  D.27171 = ins->opcode;
  D.27172 = (int) D.27171;
  D.27173 = mono_op_imm_to_op (D.27172);
  D.27174 = (short unsigned int) D.27173;
  ins->opcode = D.27174;
  D.27171 = ins->opcode;
  if (D.27171 == 338) goto <D.27175>; else goto <D.27176>;
  <D.27175>:
  D.27177 = temp->dreg;
  ins->sreg1 = D.27177;
  goto <D.27178>;
  <D.27176>:
  D.27177 = temp->dreg;
  ins->sreg2 = D.27177;
  <D.27178>:
  D.27179 = cfg->next_vreg;
  D.27180 = bb->max_vreg;
  D.27181 = MAX_EXPR <D.27179, D.27180>;
  bb->max_vreg = D.27181;
}


mono_compile_create_var_for_vreg (struct MonoCompile * cfg, struct MonoType * type, int opcode, int vreg)
{
  unsigned int D.27182;
  int D.27183;
  unsigned int D.27184;
  unsigned int D.27185;
  guint iftmp.25;
  unsigned int D.27192;
  struct MonoInst * * D.27193;
  void * D.27194;
  unsigned int D.27195;
  struct MonoMethodVar * D.27196;
  void * D.27197;
  unsigned int orig_count.26;
  unsigned int D.27199;
  unsigned int D.27200;
  unsigned int orig_count.27;
  unsigned int D.27202;
  void * D.27203;
  int D.27204;
  int D.27205;
  struct MonoMemPool * D.27206;
  int D.27207;
  struct MonoInst * D.27208;
  short unsigned int D.27209;
  int D.27210;
  int D.27211;
  const unsigned char * D.27212;
  struct MonoClass * D.27213;
  struct MonoClass * D.27214;
  unsigned char D.27215;
  unsigned char D.27218;
  unsigned char D.27219;
  unsigned char D.27222;
  unsigned char D.27223;
  int D.27230;
  unsigned char D.27232;
  unsigned char D.27233;
  int D.27234;
  unsigned char D.27235;
  unsigned char D.27236;
  unsigned int num.28;
  unsigned int D.27238;
  struct MonoInst * * D.27239;
  unsigned int D.27240;
  struct MonoMethodVar * D.27241;
  unsigned int num.29;
  int D.27245;
  int iftmp.30;
  struct MonoType * D.27254;
  unsigned char D.27255;
  struct MonoType * D.27257;
  unsigned char D.27258;
  unsigned char D.27260;
  unsigned char D.27261;
  int iftmp.31;
  struct MonoType * D.27268;
  unsigned char D.27269;
  struct MonoType * D.27271;
  unsigned char D.27272;
  unsigned int D.27275;
  int D.27278;
  int D.27279;
  int D.27280;
  int D.27281;
  unsigned int D.27284;
  unsigned int D.27285;
  int D.27292;
  struct MonoInst * D.27293;
  int D.27294;
  int D.27295;
  struct MonoClass * D.27298;
  struct MonoType * D.27299;
  struct MonoType * D.27300;
  struct MonoClass * D.27301;
  struct MonoClass * D.27304;
  unsigned int D.27305;
  char * D.27308;
  struct MonoInst * D.27309;
  struct MonoInst * inst;
  int num;
  gboolean regpair;

  D.27182 = cfg->num_varinfo;
  num = (int) D.27182;
  type = mini_replace_type (type);
  D.27183 = num + 1;
  D.27184 = (unsigned int) D.27183;
  D.27185 = cfg->varinfo_count;
  if (D.27184 >= D.27185) goto <D.27186>; else goto <D.27187>;
  <D.27186>:
  {
    int orig_count;

    D.27185 = cfg->varinfo_count;
    orig_count = (int) D.27185;
    D.27185 = cfg->varinfo_count;
    if (D.27185 != 0) goto <D.27189>; else goto <D.27190>;
    <D.27189>:
    D.27185 = cfg->varinfo_count;
    iftmp.25 = D.27185 * 2;
    goto <D.27191>;
    <D.27190>:
    iftmp.25 = 64;
    <D.27191>:
    cfg->varinfo_count = iftmp.25;
    D.27185 = cfg->varinfo_count;
    D.27192 = D.27185 * 4;
    D.27193 = cfg->varinfo;
    D.27194 = monoeg_realloc (D.27193, D.27192);
    cfg->varinfo = D.27194;
    D.27185 = cfg->varinfo_count;
    D.27195 = D.27185 * 56;
    D.27196 = cfg->vars;
    D.27197 = monoeg_realloc (D.27196, D.27195);
    cfg->vars = D.27197;
    D.27185 = cfg->varinfo_count;
    orig_count.26 = (unsigned int) orig_count;
    D.27199 = D.27185 - orig_count.26;
    D.27200 = D.27199 * 56;
    D.27196 = cfg->vars;
    orig_count.27 = (unsigned int) orig_count;
    D.27202 = orig_count.27 * 56;
    D.27203 = D.27196 + D.27202;
    memset (D.27203, 0, D.27200);
  }
  <D.27187>:
  D.27204 = cfg->stat_allocate_var;
  D.27205 = D.27204 + 1;
  cfg->stat_allocate_var = D.27205;
  D.27206 = cfg->mempool;
  inst = mono_mempool_alloc (D.27206, 48);
  inst->data.op[1].const_val = 0;
  D.27207 = inst->data.op[1].const_val;
  inst->data.op[0].const_val = D.27207;
  inst->prev = 0B;
  D.27208 = inst->prev;
  inst->next = D.27208;
  D.27209 = (short unsigned int) opcode;
  inst->opcode = D.27209;
  inst->flags = 0;
  inst->type = 0;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.27210 = inst->sreg3;
  inst->sreg2 = D.27210;
  D.27211 = inst->sreg2;
  inst->sreg1 = D.27211;
  D.27212 = cfg->ip;
  inst->cil_code = D.27212;
  inst->data.op[0].const_val = num;
  inst->data.op[1].vtype = type;
  D.27213 = mono_class_from_mono_type (type);
  inst->klass = D.27213;
  type_to_eval_stack_type (cfg, type, inst);
  inst->backend.is_pinvoke = 0;
  inst->dreg = vreg;
  D.27214 = inst->klass;
  D.27215 = D.27214->exception_type;
  if (D.27215 != 0) goto <D.27216>; else goto <D.27217>;
  <D.27216>:
  mono_cfg_set_exception (cfg, 7);
  <D.27217>:
  D.27218 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.27219 = D.27218 & 128;
  if (D.27219 != 0) goto <D.27220>; else goto <D.27221>;
  <D.27220>:
  D.27222 = BIT_FIELD_REF <*type, 8, 56>;
  D.27223 = D.27222 & 64;
  if (D.27223 != 0) goto <D.27224>; else goto <D.27225>;
  <D.27224>:
  mono_mark_vreg_as_mp (cfg, vreg);
  goto <D.27226>;
  <D.27225>:
  {
    struct MonoType * t;

    t = mini_replace_type (type);
    D.27230 = mono_type_is_struct (t);
    if (D.27230 != 0) goto <D.27231>; else goto <D.27227>;
    <D.27231>:
    D.27214 = inst->klass;
    D.27232 = BIT_FIELD_REF <*D.27214, 8, 184>;
    D.27233 = D.27232 & 8;
    if (D.27233 != 0) goto <D.27228>; else goto <D.27227>;
    <D.27227>:
    D.27234 = mini_type_is_reference (cfg, t);
    if (D.27234 != 0) goto <D.27228>; else goto <D.27229>;
    <D.27228>:
    D.27235 = inst->flags;
    D.27236 = D.27235 | 128;
    inst->flags = D.27236;
    mono_mark_vreg_as_ref (cfg, vreg);
    <D.27229>:
  }
  <D.27226>:
  <D.27221>:
  D.27193 = cfg->varinfo;
  num.28 = (unsigned int) num;
  D.27238 = num.28 * 4;
  D.27239 = D.27193 + D.27238;
  *D.27239 = inst;
  D.27196 = cfg->vars;
  num.28 = (unsigned int) num;
  D.27240 = num.28 * 56;
  D.27241 = D.27196 + D.27240;
  D.27241->range.first_use.pos.bid = 65535;
  D.27196 = cfg->vars;
  num.28 = (unsigned int) num;
  D.27240 = num.28 * 56;
  D.27241 = D.27196 + D.27240;
  D.27241->reg = -1;
  D.27196 = cfg->vars;
  num.28 = (unsigned int) num;
  D.27240 = num.28 * 56;
  D.27241 = D.27196 + D.27240;
  num.29 = (unsigned int) num;
  D.27241->idx = num.29;
  D.27196 = cfg->vars;
  num.28 = (unsigned int) num;
  D.27240 = num.28 * 56;
  D.27241 = D.27196 + D.27240;
  D.27241->vreg = vreg;
  if (vreg != -1) goto <D.27243>; else goto <D.27244>;
  <D.27243>:
  set_vreg_to_inst (cfg, vreg, inst);
  <D.27244>:
  D.27245 = mono_arch_is_soft_float ();
  if (D.27245 != 0) goto <D.27246>; else goto <D.27247>;
  <D.27246>:
  D.27222 = BIT_FIELD_REF <*type, 8, 56>;
  D.27223 = D.27222 & 64;
  if (D.27223 == 0) goto <D.27253>; else goto <D.27249>;
  <D.27253>:
  D.27254 = mono_type_get_underlying_type (type);
  D.27255 = D.27254->type;
  if (D.27255 == 10) goto <D.27250>; else goto <D.27256>;
  <D.27256>:
  D.27257 = mono_type_get_underlying_type (type);
  D.27258 = D.27257->type;
  if (D.27258 == 11) goto <D.27250>; else goto <D.27249>;
  <D.27249>:
  D.27222 = BIT_FIELD_REF <*type, 8, 56>;
  D.27223 = D.27222 & 64;
  if (D.27223 == 0) goto <D.27259>; else goto <D.27251>;
  <D.27259>:
  D.27260 = type->type;
  D.27261 = D.27260 + 244;
  if (D.27261 <= 1) goto <D.27250>; else goto <D.27251>;
  <D.27250>:
  iftmp.30 = 1;
  goto <D.27252>;
  <D.27251>:
  iftmp.30 = 0;
  <D.27252>:
  regpair = iftmp.30;
  goto <D.27262>;
  <D.27247>:
  D.27222 = BIT_FIELD_REF <*type, 8, 56>;
  D.27223 = D.27222 & 64;
  if (D.27223 == 0) goto <D.27267>; else goto <D.27264>;
  <D.27267>:
  D.27268 = mono_type_get_underlying_type (type);
  D.27269 = D.27268->type;
  if (D.27269 == 10) goto <D.27265>; else goto <D.27270>;
  <D.27270>:
  D.27271 = mono_type_get_underlying_type (type);
  D.27272 = D.27271->type;
  if (D.27272 == 11) goto <D.27265>; else goto <D.27264>;
  <D.27265>:
  iftmp.31 = 1;
  goto <D.27266>;
  <D.27264>:
  iftmp.31 = 0;
  <D.27266>:
  regpair = iftmp.31;
  <D.27262>:
  if (regpair != 0) goto <D.27273>; else goto <D.27274>;
  <D.27273>:
  {
    struct MonoInst * tree;

    D.27275 = cfg->verbose_level;
    if (D.27275 > 3) goto <D.27276>; else goto <D.27277>;
    <D.27276>:
    D.27278 = inst->dreg;
    D.27279 = D.27278 + 2;
    D.27278 = inst->dreg;
    D.27280 = D.27278 + 1;
    D.27278 = inst->dreg;
    printf ("  Create LVAR R%d (R%d, R%d)\n", D.27278, D.27280, D.27279);
    <D.27277>:
    D.27281 = mono_arch_is_soft_float ();
    if (D.27281 != 0) goto <D.27282>; else goto <D.27283>;
    <D.27282>:
    D.27284 = cfg->opt;
    D.27285 = D.27284 & 2097152;
    if (D.27285 != 0) goto <D.27286>; else goto <D.27287>;
    <D.27286>:
    D.27222 = BIT_FIELD_REF <*type, 8, 56>;
    D.27223 = D.27222 & 64;
    if (D.27223 == 0) goto <D.27288>; else goto <D.27289>;
    <D.27288>:
    D.27260 = type->type;
    D.27261 = D.27260 + 244;
    if (D.27261 <= 1) goto <D.27290>; else goto <D.27291>;
    <D.27290>:
    inst->flags = 4;
    <D.27291>:
    <D.27289>:
    <D.27287>:
    <D.27283>:
    D.27206 = cfg->mempool;
    tree = mono_mempool_alloc (D.27206, 48);
    tree->data.op[1].const_val = 0;
    D.27292 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.27292;
    tree->prev = 0B;
    D.27293 = tree->prev;
    tree->next = D.27293;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.27294 = tree->sreg3;
    tree->sreg2 = D.27294;
    D.27295 = tree->sreg2;
    tree->sreg1 = D.27295;
    D.27212 = cfg->ip;
    tree->cil_code = D.27212;
    D.27278 = inst->dreg;
    D.27280 = D.27278 + 1;
    tree->dreg = D.27280;
    D.27284 = cfg->opt;
    D.27285 = D.27284 & 2097152;
    if (D.27285 != 0) goto <D.27296>; else goto <D.27297>;
    <D.27296>:
    tree->flags = 4;
    <D.27297>:
    tree->data.op[0].const_val = num;
    tree->type = 1;
    D.27298 = mono_defaults.int32_class;
    D.27299 = &D.27298->byval_arg;
    tree->data.op[1].vtype = D.27299;
    D.27300 = tree->data.op[1].vtype;
    D.27301 = mono_class_from_mono_type (D.27300);
    tree->klass = D.27301;
    D.27278 = inst->dreg;
    D.27280 = D.27278 + 1;
    set_vreg_to_inst (cfg, D.27280, tree);
    D.27206 = cfg->mempool;
    tree = mono_mempool_alloc (D.27206, 48);
    tree->data.op[1].const_val = 0;
    D.27292 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.27292;
    tree->prev = 0B;
    D.27293 = tree->prev;
    tree->next = D.27293;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.27294 = tree->sreg3;
    tree->sreg2 = D.27294;
    D.27295 = tree->sreg2;
    tree->sreg1 = D.27295;
    D.27212 = cfg->ip;
    tree->cil_code = D.27212;
    D.27278 = inst->dreg;
    D.27279 = D.27278 + 2;
    tree->dreg = D.27279;
    D.27284 = cfg->opt;
    D.27285 = D.27284 & 2097152;
    if (D.27285 != 0) goto <D.27302>; else goto <D.27303>;
    <D.27302>:
    tree->flags = 4;
    <D.27303>:
    tree->data.op[0].const_val = num;
    tree->type = 1;
    D.27298 = mono_defaults.int32_class;
    D.27299 = &D.27298->byval_arg;
    tree->data.op[1].vtype = D.27299;
    D.27300 = tree->data.op[1].vtype;
    D.27304 = mono_class_from_mono_type (D.27300);
    tree->klass = D.27304;
    D.27278 = inst->dreg;
    D.27279 = D.27278 + 2;
    set_vreg_to_inst (cfg, D.27279, tree);
  }
  <D.27274>:
  D.27182 = cfg->num_varinfo;
  D.27305 = D.27182 + 1;
  cfg->num_varinfo = D.27305;
  D.27275 = cfg->verbose_level;
  if (D.27275 > 2) goto <D.27306>; else goto <D.27307>;
  <D.27306>:
  D.27308 = mono_type_get_name (type);
  monoeg_g_print ("created temp %d (R%d) of type %s\n", num, vreg, D.27308);
  <D.27307>:
  D.27309 = inst;
  return D.27309;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.27313;
  int D.27318;
  void * D.27320;
  unsigned int D.27321;

  D.27313 = __builtin_constant_p (__len);
  if (D.27313 != 0) goto <D.27314>; else goto <D.27315>;
  <D.27314>:
  if (__len == 0) goto <D.27316>; else goto <D.27317>;
  <D.27316>:
  D.27318 = __builtin_constant_p (__ch);
  if (D.27318 == 0) goto <D.27311>; else goto <D.27319>;
  <D.27319>:
  if (__ch != 0) goto <D.27311>; else goto <D.27312>;
  <D.27311>:
  __warn_memset_zero_len ();
  D.27320 = __dest;
  return D.27320;
  <D.27312>:
  <D.27317>:
  <D.27315>:
  D.27321 = __builtin_object_size (__dest, 0);
  D.27320 = __builtin___memset_chk (__dest, __ch, __len, D.27321);
  return D.27320;
}


mono_arch_is_soft_float ()
{
  gboolean D.27323;

  D.27323 = 0;
  return D.27323;
}


set_vreg_to_inst (struct MonoCompile * cfg, int vreg, struct MonoInst * inst)
{
  unsigned int vreg.32;
  unsigned int D.27326;
  guint32 iftmp.33;
  unsigned int D.27333;
  struct MonoMemPool * D.27334;
  void * D.27335;
  unsigned int size.34;
  unsigned int D.27339;
  struct MonoInst * * D.27340;
  unsigned int vreg.35;
  unsigned int D.27342;
  struct MonoInst * * D.27343;

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

    tmp = cfg->vreg_to_inst;
    D.27326 = cfg->vreg_to_inst_len;
    size = (int) D.27326;
    goto <D.24913>;
    <D.24912>:
    D.27326 = cfg->vreg_to_inst_len;
    if (D.27326 != 0) goto <D.27330>; else goto <D.27331>;
    <D.27330>:
    D.27326 = cfg->vreg_to_inst_len;
    iftmp.33 = D.27326 * 2;
    goto <D.27332>;
    <D.27331>:
    iftmp.33 = 32;
    <D.27332>:
    cfg->vreg_to_inst_len = iftmp.33;
    <D.24913>:
    vreg.32 = (unsigned int) vreg;
    D.27326 = cfg->vreg_to_inst_len;
    if (vreg.32 >= D.27326) goto <D.24912>; else goto <D.24914>;
    <D.24914>:
    D.27326 = cfg->vreg_to_inst_len;
    D.27333 = D.27326 * 4;
    D.27334 = cfg->mempool;
    D.27335 = mono_mempool_alloc0 (D.27334, D.27333);
    cfg->vreg_to_inst = D.27335;
    if (size != 0) goto <D.27336>; else goto <D.27337>;
    <D.27336>:
    size.34 = (unsigned int) size;
    D.27339 = size.34 * 4;
    D.27340 = cfg->vreg_to_inst;
    memcpy (D.27340, tmp, D.27339);
    <D.27337>:
  }
  <D.27328>:
  D.27340 = cfg->vreg_to_inst;
  vreg.35 = (unsigned int) vreg;
  D.27342 = vreg.35 * 4;
  D.27343 = D.27340 + D.27342;
  *D.27343 = inst;
}


mono_compile_create_var (struct MonoCompile * cfg, struct MonoType * type, int opcode)
{
  unsigned char D.27347;
  unsigned char D.27348;
  struct MonoType * D.27350;
  unsigned char D.27351;
  struct MonoType * D.27353;
  unsigned char D.27354;
  unsigned int D.27355;
  int D.27358;
  unsigned char D.27361;
  unsigned char D.27362;
  unsigned int D.27364;
  unsigned int D.27365;
  struct MonoInst * D.27366;
  int dreg;

  type = mini_replace_type (type);
  D.27347 = BIT_FIELD_REF <*type, 8, 56>;
  D.27348 = D.27347 & 64;
  if (D.27348 == 0) goto <D.27349>; else goto <D.27344>;
  <D.27349>:
  D.27350 = mono_type_get_underlying_type (type);
  D.27351 = D.27350->type;
  if (D.27351 == 10) goto <D.27345>; else goto <D.27352>;
  <D.27352>:
  D.27353 = mono_type_get_underlying_type (type);
  D.27354 = D.27353->type;
  if (D.27354 == 11) goto <D.27345>; else goto <D.27344>;
  <D.27345>:
  D.27355 = mono_alloc_dreg (cfg, 2);
  dreg = (int) D.27355;
  goto <D.27346>;
  <D.27344>:
  D.27358 = mono_arch_is_soft_float ();
  if (D.27358 != 0) goto <D.27359>; else goto <D.27356>;
  <D.27359>:
  D.27347 = BIT_FIELD_REF <*type, 8, 56>;
  D.27348 = D.27347 & 64;
  if (D.27348 == 0) goto <D.27360>; else goto <D.27356>;
  <D.27360>:
  D.27361 = type->type;
  D.27362 = D.27361 + 244;
  if (D.27362 <= 1) goto <D.27363>; else goto <D.27356>;
  <D.27363>:
  D.27364 = mono_alloc_dreg (cfg, 4);
  dreg = (int) D.27364;
  goto <D.27357>;
  <D.27356>:
  D.27365 = mono_alloc_preg (cfg);
  dreg = (int) D.27365;
  <D.27357>:
  <D.27346>:
  D.27366 = mono_compile_create_var_for_vreg (cfg, type, opcode, dreg);
  return D.27366;
}


mono_compile_make_var_load (struct MonoCompile * cfg, struct MonoInst * dest, gssize var_index)
{
  struct MonoInst * * D.27368;
  unsigned int var_index.36;
  unsigned int D.27370;
  struct MonoInst * * D.27371;
  struct MonoInst * D.27372;
  struct MonoInst * D.27373;
  struct MonoType * D.27374;
  unsigned int D.27375;
  short unsigned int D.27376;
  struct MonoClass * D.27377;

  memset (dest, 0, 48);
  D.27368 = cfg->varinfo;
  var_index.36 = (unsigned int) var_index;
  D.27370 = var_index.36 * 4;
  D.27371 = D.27368 + D.27370;
  D.27372 = *D.27371;
  dest->data.op[0].src = D.27372;
  D.27373 = dest->data.op[0].src;
  D.27374 = D.27373->data.op[1].vtype;
  D.27375 = mini_type_to_ldind (cfg, D.27374);
  D.27376 = (short unsigned int) D.27375;
  dest->opcode = D.27376;
  D.27373 = dest->data.op[0].src;
  D.27374 = D.27373->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.27374, dest);
  D.27373 = dest->data.op[0].src;
  D.27377 = D.27373->klass;
  dest->klass = D.27377;
}


mini_type_to_ldind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.27378;
  unsigned char D.27381;
  unsigned char D.27382;
  unsigned char D.27385;
  _Bool D.27386;
  _Bool D.27387;
  _Bool D.27388;
  int D.27391;
  guint D.27394;

  D.27378 = cfg->generic_sharing_context;
  if (D.27378 != 0B) goto <D.27379>; else goto <D.27380>;
  <D.27379>:
  D.27381 = BIT_FIELD_REF <*type, 8, 56>;
  D.27382 = D.27381 & 64;
  if (D.27382 == 0) goto <D.27383>; else goto <D.27384>;
  <D.27383>:
  D.27385 = type->type;
  D.27386 = D.27385 == 19;
  D.27387 = D.27385 == 30;
  D.27388 = D.27386 | D.27387;
  if (D.27388 != 0) goto <D.27389>; else goto <D.27390>;
  <D.27389>:
  D.27391 = mini_type_var_is_vt (cfg, type);
  if (D.27391 != 0) goto <D.27392>; else goto <D.27393>;
  <D.27392>:
  D.27394 = 113;
  return D.27394;
  <D.27393>:
  D.27394 = 80;
  return D.27394;
  <D.27390>:
  <D.27384>:
  <D.27380>:
  D.27394 = mono_type_to_ldind (type);
  return D.27394;
}


mono_mark_vreg_as_ref (struct MonoCompile * cfg, int vreg)
{
  unsigned int vreg.37;
  unsigned int D.27397;
  guint32 iftmp.38;
  unsigned int D.27404;
  struct MonoMemPool * D.27405;
  void * D.27406;
  unsigned int size.39;
  unsigned int D.27410;
  gboolean * D.27411;
  unsigned int vreg.40;
  unsigned int D.27413;
  gboolean * D.27414;

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

    tmp = cfg->vreg_is_ref;
    D.27397 = cfg->vreg_is_ref_len;
    size = (int) D.27397;
    goto <D.24945>;
    <D.24944>:
    D.27397 = cfg->vreg_is_ref_len;
    if (D.27397 != 0) goto <D.27401>; else goto <D.27402>;
    <D.27401>:
    D.27397 = cfg->vreg_is_ref_len;
    iftmp.38 = D.27397 * 2;
    goto <D.27403>;
    <D.27402>:
    iftmp.38 = 32;
    <D.27403>:
    cfg->vreg_is_ref_len = iftmp.38;
    <D.24945>:
    vreg.37 = (unsigned int) vreg;
    D.27397 = cfg->vreg_is_ref_len;
    if (vreg.37 >= D.27397) goto <D.24944>; else goto <D.24946>;
    <D.24946>:
    D.27397 = cfg->vreg_is_ref_len;
    D.27404 = D.27397 * 4;
    D.27405 = cfg->mempool;
    D.27406 = mono_mempool_alloc0 (D.27405, D.27404);
    cfg->vreg_is_ref = D.27406;
    if (size != 0) goto <D.27407>; else goto <D.27408>;
    <D.27407>:
    size.39 = (unsigned int) size;
    D.27410 = size.39 * 4;
    D.27411 = cfg->vreg_is_ref;
    memcpy (D.27411, tmp, D.27410);
    <D.27408>:
  }
  <D.27399>:
  D.27411 = cfg->vreg_is_ref;
  vreg.40 = (unsigned int) vreg;
  D.27413 = vreg.40 * 4;
  D.27414 = D.27411 + D.27413;
  *D.27414 = 1;
}


mono_mark_vreg_as_mp (struct MonoCompile * cfg, int vreg)
{
  unsigned int vreg.41;
  unsigned int D.27416;
  guint32 iftmp.42;
  unsigned int D.27423;
  struct MonoMemPool * D.27424;
  void * D.27425;
  unsigned int size.43;
  unsigned int D.27429;
  gboolean * D.27430;
  unsigned int vreg.44;
  unsigned int D.27432;
  gboolean * D.27433;

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

    tmp = cfg->vreg_is_mp;
    D.27416 = cfg->vreg_is_mp_len;
    size = (int) D.27416;
    goto <D.24954>;
    <D.24953>:
    D.27416 = cfg->vreg_is_mp_len;
    if (D.27416 != 0) goto <D.27420>; else goto <D.27421>;
    <D.27420>:
    D.27416 = cfg->vreg_is_mp_len;
    iftmp.42 = D.27416 * 2;
    goto <D.27422>;
    <D.27421>:
    iftmp.42 = 32;
    <D.27422>:
    cfg->vreg_is_mp_len = iftmp.42;
    <D.24954>:
    vreg.41 = (unsigned int) vreg;
    D.27416 = cfg->vreg_is_mp_len;
    if (vreg.41 >= D.27416) goto <D.24953>; else goto <D.24955>;
    <D.24955>:
    D.27416 = cfg->vreg_is_mp_len;
    D.27423 = D.27416 * 4;
    D.27424 = cfg->mempool;
    D.27425 = mono_mempool_alloc0 (D.27424, D.27423);
    cfg->vreg_is_mp = D.27425;
    if (size != 0) goto <D.27426>; else goto <D.27427>;
    <D.27426>:
    size.43 = (unsigned int) size;
    D.27429 = size.43 * 4;
    D.27430 = cfg->vreg_is_mp;
    memcpy (D.27430, tmp, D.27429);
    <D.27427>:
  }
  <D.27418>:
  D.27430 = cfg->vreg_is_mp;
  vreg.44 = (unsigned int) vreg;
  D.27432 = vreg.44 * 4;
  D.27433 = D.27430 + D.27432;
  *D.27433 = 1;
}


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

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


type_from_stack_type (struct MonoInst * ins)
{
  unsigned char D.27436;
  int D.27437;
  struct MonoType * D.27438;
  struct MonoClass * D.27439;
  struct MonoClass * D.27440;
  struct MonoClass * D.27441;
  struct MonoClass * D.27442;
  struct MonoClass * D.27443;
  struct MonoClass * D.27446;
  unsigned char D.27449;
  unsigned char D.27450;

  D.27436 = ins->type;
  D.27437 = (int) D.27436;
  switch (D.27437) <default: <D.24966>, case 1: <D.24959>, case 2: <D.24960>, case 3: <D.24961>, case 4: <D.24962>, case 5: <D.24963>, case 6: <D.24964>, case 7: <D.24965>>
  <D.24959>:
  D.27439 = mono_defaults.int32_class;
  D.27438 = &D.27439->byval_arg;
  return D.27438;
  <D.24960>:
  D.27440 = mono_defaults.int64_class;
  D.27438 = &D.27440->byval_arg;
  return D.27438;
  <D.24961>:
  D.27441 = mono_defaults.int_class;
  D.27438 = &D.27441->byval_arg;
  return D.27438;
  <D.24962>:
  D.27442 = mono_defaults.double_class;
  D.27438 = &D.27442->byval_arg;
  return D.27438;
  <D.24963>:
  D.27443 = ins->klass;
  if (D.27443 != 0B) goto <D.27444>; else goto <D.27445>;
  <D.27444>:
  D.27443 = ins->klass;
  D.27438 = &D.27443->this_arg;
  return D.27438;
  <D.27445>:
  D.27446 = mono_defaults.object_class;
  D.27438 = &D.27446->this_arg;
  return D.27438;
  <D.24964>:
  D.27443 = ins->klass;
  if (D.27443 != 0B) goto <D.27447>; else goto <D.27448>;
  <D.27447>:
  D.27443 = ins->klass;
  D.27449 = BIT_FIELD_REF <*D.27443, 8, 160>;
  D.27450 = D.27449 & 8;
  if (D.27450 == 0) goto <D.27451>; else goto <D.27452>;
  <D.27451>:
  D.27443 = ins->klass;
  D.27438 = &D.27443->byval_arg;
  return D.27438;
  <D.27452>:
  <D.27448>:
  D.27446 = mono_defaults.object_class;
  D.27438 = &D.27446->byval_arg;
  return D.27438;
  <D.24965>:
  D.27443 = ins->klass;
  D.27438 = &D.27443->byval_arg;
  return D.27438;
  <D.24966>:
  D.27436 = ins->type;
  D.27437 = (int) D.27436;
  monoeg_g_log (0B, 4, "stack type %d to montype not handled\n", D.27437);
  <D.24967>:
  goto <D.24967>;
  D.27438 = 0B;
  return D.27438;
}


mono_add_ins_to_end (struct MonoBasicBlock * bb, struct MonoInst * inst)
{
  struct MonoInst * D.27454;
  struct MonoInst * D.27457;
  short unsigned int D.27461;
  int D.27462;
  short unsigned int D.27466;
  short unsigned int D.27467;
  _Bool D.27468;
  short unsigned int D.27469;
  _Bool D.27470;
  _Bool D.27471;
  short unsigned int D.27473;
  struct MonoInst * D.27476;
  short unsigned int D.27479;
  unsigned int opcode.45;
  unsigned int D.27484;
  _Bool D.27485;
  _Bool D.27486;
  _Bool D.27487;
  _Bool D.27489;
  _Bool D.27490;
  _Bool D.27491;
  _Bool D.27493;
  _Bool D.27494;
  _Bool D.27495;
  struct MonoInst * D.27497;
  short unsigned int D.27498;
  int opcode;

  D.27454 = bb->code;
  if (D.27454 == 0B) goto <D.27455>; else goto <D.27456>;
  <D.27455>:
  D.27457 = bb->last_ins;
  if (D.27457 != 0B) goto <D.27458>; else goto <D.27459>;
  <D.27458>:
  D.27457 = bb->last_ins;
  D.27457->next = inst;
  D.27457 = bb->last_ins;
  inst->prev = D.27457;
  bb->last_ins = inst;
  goto <D.27460>;
  <D.27459>:
  bb->last_ins = inst;
  D.27457 = bb->last_ins;
  bb->code = D.27457;
  <D.27460>:
  return;
  <D.27456>:
  D.27457 = bb->last_ins;
  D.27461 = D.27457->opcode;
  D.27462 = (int) D.27461;
  switch (D.27462) <default: <D.24990>, case 59: <D.24978>, case 60: <D.24979>, case 61: <D.24980>, case 62: <D.24981>, case 63: <D.24982>, case 64: <D.24983>, case 65: <D.24984>, case 66: <D.24985>, case 67: <D.24986>, case 68: <D.24987>, case 370: <D.24988>, case 446: <D.24976>, case 763: <D.24977>>
  <D.24976>:
  <D.24977>:
  <D.24978>:
  <D.24979>:
  <D.24980>:
  <D.24981>:
  <D.24982>:
  <D.24983>:
  <D.24984>:
  <D.24985>:
  <D.24986>:
  <D.24987>:
  <D.24988>:
  D.27457 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27457, inst);
  goto <D.24989>;
  <D.24990>:
  D.27457 = bb->last_ins;
  D.27466 = D.27457->opcode;
  D.27467 = D.27466 + 64981;
  D.27468 = D.27467 <= 9;
  D.27469 = D.27466 + 64874;
  D.27470 = D.27469 <= 9;
  D.27471 = D.27468 | D.27470;
  if (D.27471 != 0) goto <D.27463>; else goto <D.27472>;
  <D.27472>:
  D.27457 = bb->last_ins;
  D.27461 = D.27457->opcode;
  D.27473 = D.27461 + 64884;
  if (D.27473 <= 9) goto <D.27463>; else goto <D.27464>;
  <D.27463>:
  D.27454 = bb->code;
  D.27457 = bb->last_ins;
  if (D.27454 == D.27457) goto <D.27474>; else goto <D.27475>;
  <D.27474>:
  D.27457 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27457, inst);
  return;
  <D.27475>:
  D.27454 = bb->code;
  D.27476 = D.27454->next;
  D.27457 = bb->last_ins;
  if (D.27476 == D.27457) goto <D.27477>; else goto <D.27478>;
  <D.27477>:
  D.27454 = bb->code;
  D.27479 = D.27454->opcode;
  opcode = (int) D.27479;
  opcode.45 = (unsigned int) opcode;
  D.27484 = opcode.45 + 4294966974;
  D.27485 = D.27484 <= 1;
  D.27486 = opcode == 326;
  D.27487 = D.27485 | D.27486;
  if (D.27487 != 0) goto <D.27480>; else goto <D.27488>;
  <D.27488>:
  D.27489 = opcode == 327;
  D.27490 = opcode == 324;
  D.27491 = D.27489 | D.27490;
  if (D.27491 != 0) goto <D.27480>; else goto <D.27492>;
  <D.27492>:
  D.27493 = opcode == 325;
  D.27494 = opcode == 328;
  D.27495 = D.27493 | D.27494;
  if (D.27495 != 0) goto <D.27480>; else goto <D.27481>;
  <D.27480>:
  D.27454 = bb->code;
  mono_bblock_insert_before_ins (bb, D.27454, inst);
  goto <D.27482>;
  <D.27481>:
  D.27457 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27457, inst);
  <D.27482>:
  goto <D.27496>;
  <D.27478>:
  D.27457 = bb->last_ins;
  D.27497 = D.27457->prev;
  D.27498 = D.27497->opcode;
  opcode = (int) D.27498;
  opcode.45 = (unsigned int) opcode;
  D.27484 = opcode.45 + 4294966974;
  D.27485 = D.27484 <= 1;
  D.27486 = opcode == 326;
  D.27487 = D.27485 | D.27486;
  if (D.27487 != 0) goto <D.27499>; else goto <D.27502>;
  <D.27502>:
  D.27489 = opcode == 327;
  D.27490 = opcode == 324;
  D.27491 = D.27489 | D.27490;
  if (D.27491 != 0) goto <D.27499>; else goto <D.27503>;
  <D.27503>:
  D.27493 = opcode == 325;
  D.27494 = opcode == 328;
  D.27495 = D.27493 | D.27494;
  if (D.27495 != 0) goto <D.27499>; else goto <D.27500>;
  <D.27499>:
  D.27457 = bb->last_ins;
  D.27497 = D.27457->prev;
  mono_bblock_insert_before_ins (bb, D.27497, inst);
  goto <D.27501>;
  <D.27500>:
  D.27457 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27457, inst);
  <D.27501>:
  <D.27496>:
  goto <D.27465>;
  <D.27464>:
  D.27457 = bb->last_ins;
  if (D.27457 != 0B) goto <D.27504>; else goto <D.27505>;
  <D.27504>:
  D.27457 = bb->last_ins;
  D.27457->next = inst;
  D.27457 = bb->last_ins;
  inst->prev = D.27457;
  bb->last_ins = inst;
  goto <D.27506>;
  <D.27505>:
  bb->last_ins = inst;
  D.27457 = bb->last_ins;
  bb->code = D.27457;
  <D.27506>:
  <D.27465>:
  goto <D.24989>;
  <D.24989>:
}


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

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


mono_get_array_new_va_icall (int rank)
{
  _Bool D.27512;
  long int D.27513;
  long int D.27514;
  struct GHashTable * jit_icall_name_hash.46;
  _Bool D.27522;
  long int D.27523;
  long int D.27524;
  struct MonoJitICallInfo * D.27527;
  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.27510>; else goto <D.27511>;
        <D.27510>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27511>:
        D.27512 = ret != 0;
        D.27513 = (long int) D.27512;
        D.27514 = __builtin_expect (D.27513, 0);
        if (D.27514 != 0) goto <D.27515>; else goto <D.27516>;
        <D.27515>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1561, "ret == 0");
        <D.27516>:
      }
      info = mono_find_jit_icall_by_name (&icall_name);
      if (info == 0B) goto <D.27517>; else goto <D.27518>;
      <D.27517>:
      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.27518>:
      {
        int ret;

        ret = pthread_mutex_unlock (&jit_mutex.mutex);
        if (ret != 0) goto <D.27520>; else goto <D.27521>;
        <D.27520>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27521>:
        D.27522 = ret != 0;
        D.27523 = (long int) D.27522;
        D.27524 = __builtin_expect (D.27523, 0);
        if (D.27524 != 0) goto <D.27525>; else goto <D.27526>;
        <D.27525>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1570, "ret == 0");
        <D.27526>:
      }
      D.27527 = info;
      return D.27527;
    }
  finally
    {
      icall_name = {CLOBBER};
    }
}


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

  D.27531 = __builtin_object_size (__s, 1);
  D.27530 = __builtin___sprintf_chk (__s, 1, D.27531, __fmt, __builtin_va_arg_pack ());
  return D.27530;
}


mono_get_array_new_va_signature (int arity)
{
  _Bool D.27535;
  long int D.27536;
  long int D.27537;
  struct GHashTable * sighash.47;
  struct GHashTable * sighash.48;
  const void * arity.49;
  _Bool D.27550;
  long int D.27551;
  long int D.27552;
  struct MonoMethodSignature * D.27555;
  int D.27556;
  unsigned int D.27557;
  struct MonoImage * D.27558;
  struct MonoClass * D.27561;
  struct MonoType * D.27562;
  int D.27563;
  struct MonoClass * D.27564;
  struct MonoType * D.27565;
  void * arity.50;
  _Bool D.27569;
  long int D.27570;
  long int D.27571;
  static struct GHashTable * sighash = 0B;
  struct MonoMethodSignature * res;
  int i;

  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27533>; else goto <D.27534>;
    <D.27533>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27534>:
    D.27535 = ret != 0;
    D.27536 = (long int) D.27535;
    D.27537 = __builtin_expect (D.27536, 0);
    if (D.27537 != 0) goto <D.27538>; else goto <D.27539>;
    <D.27538>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1518, "ret == 0");
    <D.27539>:
  }
  sighash.47 = sighash;
  if (sighash.47 == 0B) goto <D.27541>; else goto <D.27542>;
  <D.27541>:
  sighash.48 = monoeg_g_hash_table_new (0B, 0B);
  sighash = sighash.48;
  goto <D.27544>;
  <D.27542>:
  arity.49 = (const void *) arity;
  sighash.47 = sighash;
  res = monoeg_g_hash_table_lookup (sighash.47, arity.49);
  if (res != 0B) goto <D.27546>; else goto <D.27547>;
  <D.27546>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27548>; else goto <D.27549>;
    <D.27548>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27549>:
    D.27550 = ret != 0;
    D.27551 = (long int) D.27550;
    D.27552 = __builtin_expect (D.27551, 0);
    if (D.27552 != 0) goto <D.27553>; else goto <D.27554>;
    <D.27553>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1523, "ret == 0");
    <D.27554>:
  }
  D.27555 = res;
  return D.27555;
  <D.27547>:
  <D.27544>:
  D.27556 = arity + 1;
  D.27557 = (unsigned int) D.27556;
  D.27558 = mono_defaults.corlib;
  res = mono_metadata_signature_alloc (D.27558, D.27557);
  res->pinvoke = 1;
  if (0 != 0) goto <D.27559>; else goto <D.27560>;
  <D.27559>:
  res->call_convention = 5;
  <D.27560>:
  D.27561 = mono_defaults.int_class;
  D.27562 = &D.27561->byval_arg;
  res->params[0] = D.27562;
  i = 0;
  goto <D.25008>;
  <D.25007>:
  D.27563 = i + 1;
  D.27561 = mono_defaults.int_class;
  D.27562 = &D.27561->byval_arg;
  res->params[D.27563] = D.27562;
  i = i + 1;
  <D.25008>:
  if (i < arity) goto <D.25007>; else goto <D.25009>;
  <D.25009>:
  D.27564 = mono_defaults.object_class;
  D.27565 = &D.27564->byval_arg;
  res->ret = D.27565;
  arity.50 = (void *) arity;
  sighash.47 = sighash;
  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.27567>; else goto <D.27568>;
    <D.27567>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27568>:
    D.27569 = ret != 0;
    D.27570 = (long int) D.27569;
    D.27571 = __builtin_expect (D.27570, 0);
    if (D.27571 != 0) goto <D.27572>; else goto <D.27573>;
    <D.27572>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1545, "ret == 0");
    <D.27573>:
  }
  D.27555 = res;
  return D.27555;
}


mini_class_is_system_array (struct MonoClass * klass)
{
  struct MonoClass * D.27575;
  struct MonoClass * D.27576;
  gboolean D.27579;

  D.27575 = klass->parent;
  D.27576 = mono_defaults.array_class;
  if (D.27575 == D.27576) goto <D.27577>; else goto <D.27578>;
  <D.27577>:
  D.27579 = 1;
  return D.27579;
  <D.27578>:
  D.27579 = 0;
  return D.27579;
}


mini_assembly_can_skip_verification (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoClass * D.27581;
  struct MonoImage * D.27582;
  unsigned char D.27583;
  unsigned char D.27584;
  _Bool D.27585;
  _Bool D.27586;
  _Bool D.27587;
  gboolean D.27590;
  unsigned char D.27593;
  struct MonoImage * D.27595;
  struct MonoImage * D.27596;
  int D.27597;
  struct MonoAssembly * assembly;

  D.27581 = method->klass;
  D.27582 = D.27581->image;
  assembly = D.27582->assembly;
  D.27583 = BIT_FIELD_REF <*method, 8, 160>;
  D.27584 = D.27583 & 124;
  D.27585 = D.27584 != 0;
  D.27586 = D.27584 != 68;
  D.27587 = D.27585 & D.27586;
  if (D.27587 != 0) goto <D.27588>; else goto <D.27589>;
  <D.27588>:
  D.27590 = 0;
  return D.27590;
  <D.27589>:
  D.27593 = assembly->in_gac;
  if (D.27593 != 0) goto <D.27591>; else goto <D.27594>;
  <D.27594>:
  D.27595 = assembly->image;
  D.27596 = mono_defaults.corlib;
  if (D.27595 == D.27596) goto <D.27591>; else goto <D.27592>;
  <D.27591>:
  D.27590 = 0;
  return D.27590;
  <D.27592>:
  D.27597 = mono_is_security_manager_active ();
  if (D.27597 != 0) goto <D.27598>; else goto <D.27599>;
  <D.27598>:
  D.27590 = 0;
  return D.27590;
  <D.27599>:
  D.27590 = mono_assembly_has_skip_verification (assembly);
  return D.27590;
}


mono_compile_is_broken (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  struct MonoClass * D.27601;
  struct MonoImage * D.27602;
  struct MonoAssembly * D.27603;
  unsigned char D.27604;
  unsigned char D.27605;
  unsigned char D.27606;
  gboolean D.27607;
  int iftmp.51;
  int D.27612;
  struct MonoMethod * method_definition;
  gboolean dont_verify;

  method_definition = method;
  D.27601 = method->klass;
  D.27602 = D.27601->image;
  D.27603 = D.27602->assembly;
  D.27604 = D.27603->corlib_internal;
  dont_verify = (gboolean) D.27604;
  goto <D.25052>;
  <D.25051>:
  {
    struct MonoMethodInflated * imethod;

    imethod = method_definition;
    method_definition = imethod->declaring;
  }
  <D.25052>:
  D.27605 = BIT_FIELD_REF <*method_definition, 8, 168>;
  D.27606 = D.27605 & 16;
  if (D.27606 != 0) goto <D.25051>; else goto <D.25053>;
  <D.25053>:
  if (dont_verify == 0) goto <D.27611>; else goto <D.27609>;
  <D.27611>:
  D.27612 = mini_method_verify (cfg, method_definition, fail_compile);
  if (D.27612 != 0) goto <D.27613>; else goto <D.27609>;
  <D.27613>:
  iftmp.51 = 1;
  goto <D.27610>;
  <D.27609>:
  iftmp.51 = 0;
  <D.27610>:
  D.27607 = iftmp.51;
  return D.27607;
}


mini_method_verify (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  unsigned char D.27615;
  unsigned char D.27616;
  gboolean D.27619;
  int D.27620;
  int iftmp.52;
  int D.27627;
  struct MonoDomain * D.27629;
  int D.27630;
  <unnamed-unsigned:1> D.27631;
  int D.27632;
  unsigned char D.27637;
  unsigned int D.27638;
  <unnamed type> D.27644;
  signed char D.27649;
  unsigned int D.27650;
  char * D.27651;
  gchar * D.27652;
  gchar * D.27661;
  struct GSList * tmp;
  struct GSList * res;
  gboolean is_fulltrust;
  struct MonoLoaderError * error;

  D.27615 = BIT_FIELD_REF <*method, 8, 168>;
  D.27616 = D.27615 & 64;
  if (D.27616 != 0) goto <D.27617>; else goto <D.27618>;
  <D.27617>:
  D.27619 = 0;
  return D.27619;
  <D.27618>:
  D.27620 = mono_verifier_is_enabled_for_method (method);
  if (D.27620 == 0) goto <D.27621>; else goto <D.27622>;
  <D.27621>:
  D.27619 = 0;
  return D.27619;
  <D.27622>:
  D.27627 = mono_verifier_is_method_full_trust (method);
  if (D.27627 != 0) goto <D.27624>; else goto <D.27628>;
  <D.27628>:
  D.27629 = cfg->domain;
  D.27630 = mini_assembly_can_skip_verification (D.27629, method);
  if (D.27630 != 0) goto <D.27624>; else goto <D.27625>;
  <D.27624>:
  iftmp.52 = 1;
  goto <D.27626>;
  <D.27625>:
  iftmp.52 = 0;
  <D.27626>:
  is_fulltrust = iftmp.52;
  D.27631 = cfg->skip_visibility;
  D.27632 = (int) D.27631;
  res = mono_method_verify_with_current_settings (method, D.27632, is_fulltrust);
  error = mono_loader_get_last_error ();
  if (error != 0B) goto <D.27633>; else goto <D.27634>;
  <D.27633>:
  if (fail_compile != 0) goto <D.27635>; else goto <D.27636>;
  <D.27635>:
  D.27637 = error->exception_type;
  D.27638 = (unsigned int) D.27637;
  cfg->exception_type = D.27638;
  goto <D.27639>;
  <D.27636>:
  mono_loader_clear_error ();
  <D.27639>:
  if (res != 0B) goto <D.27640>; else goto <D.27641>;
  <D.27640>:
  mono_free_verify_list (res);
  <D.27641>:
  D.27619 = 1;
  return D.27619;
  <D.27634>:
  if (res != 0B) goto <D.27642>; else goto <D.27643>;
  <D.27642>:
  tmp = res;
  goto <D.25041>;
  <D.25040>:
  {
    struct MonoVerifyInfoExtended * info;

    info = tmp->data;
    D.27644 = info->info.status;
    if (D.27644 == 1) goto <D.27645>; else goto <D.27646>;
    <D.27645>:
    if (fail_compile != 0) goto <D.27647>; else goto <D.27648>;
    <D.27647>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.27649 = info->exception_type;
      D.27650 = (unsigned int) D.27649;
      cfg->exception_type = D.27650;
      D.27651 = info->info.message;
      D.27652 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.27651);
      cfg->exception_message = D.27652;
      monoeg_g_free (method_name);
    }
    <D.27648>:
    mono_free_verify_list (res);
    D.27619 = 1;
    return D.27619;
    <D.27646>:
    D.27644 = info->info.status;
    if (D.27644 == 8) goto <D.27655>; else goto <D.27656>;
    <D.27655>:
    if (is_fulltrust == 0) goto <D.27653>; else goto <D.27657>;
    <D.27657>:
    D.27649 = info->exception_type;
    if (D.27649 == 9) goto <D.27653>; else goto <D.27658>;
    <D.27658>:
    D.27649 = info->exception_type;
    if (D.27649 == 10) goto <D.27653>; else goto <D.27654>;
    <D.27653>:
    if (fail_compile != 0) goto <D.27659>; else goto <D.27660>;
    <D.27659>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.27649 = info->exception_type;
      D.27650 = (unsigned int) D.27649;
      cfg->exception_type = D.27650;
      D.27651 = info->info.message;
      D.27661 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.27651);
      cfg->exception_message = D.27661;
      monoeg_g_free (method_name);
    }
    <D.27660>:
    mono_free_verify_list (res);
    D.27619 = 1;
    return D.27619;
    <D.27654>:
    <D.27656>:
  }
  tmp = tmp->next;
  <D.25041>:
  if (tmp != 0B) goto <D.25040>; else goto <D.25042>;
  <D.25042>:
  mono_free_verify_list (res);
  <D.27643>:
  method->verification_success = 1;
  D.27619 = 0;
  return D.27619;
}


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

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


mono_icall_get_wrapper_full (struct MonoJitICallInfo * callinfo, gboolean do_compile)
{
  const void * D.27665;
  const void * D.27668;
  const void * D.27669;
  union mono_mutex_t * D.27672;
  _Bool D.27675;
  long int D.27676;
  long int D.27677;
  _Bool D.27684;
  long int D.27685;
  long int D.27686;
  const char * D.27689;
  int check_for_pending_exc.53;
  const void * D.27691;
  struct MonoMethodSignature * D.27692;
  void * D.27696;
  _Bool D.27699;
  long int D.27700;
  long int D.27701;
  char * name;
  struct MonoMethod * wrapper;
  const void * trampoline;
  struct MonoDomain * domain;

  domain = mono_get_root_domain ();
  D.27665 = callinfo->wrapper;
  if (D.27665 != 0B) goto <D.27666>; else goto <D.27667>;
  <D.27666>:
  D.27668 = callinfo->wrapper;
  return D.27668;
  <D.27667>:
  D.27669 = callinfo->trampoline;
  if (D.27669 != 0B) goto <D.27670>; else goto <D.27671>;
  <D.27670>:
  D.27668 = callinfo->trampoline;
  return D.27668;
  <D.27671>:
  mono_loader_lock ();
  {
    int ret;

    D.27672 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.27672);
    if (ret != 0) goto <D.27673>; else goto <D.27674>;
    <D.27673>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27674>:
    D.27675 = ret != 0;
    D.27676 = (long int) D.27675;
    D.27677 = __builtin_expect (D.27676, 0);
    if (D.27677 != 0) goto <D.27678>; else goto <D.27679>;
    <D.27678>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1697, "ret == 0");
    <D.27679>:
  }
  D.27669 = callinfo->trampoline;
  if (D.27669 != 0B) goto <D.27680>; else goto <D.27681>;
  <D.27680>:
  {
    int ret;

    D.27672 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27672);
    if (ret != 0) goto <D.27682>; else goto <D.27683>;
    <D.27682>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27683>:
    D.27684 = ret != 0;
    D.27685 = (long int) D.27684;
    D.27686 = __builtin_expect (D.27685, 0);
    if (D.27686 != 0) goto <D.27687>; else goto <D.27688>;
    <D.27687>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1700, "ret == 0");
    <D.27688>:
  }
  mono_loader_unlock ();
  D.27668 = callinfo->trampoline;
  return D.27668;
  <D.27681>:
  D.27689 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.27689);
  check_for_pending_exc.53 = check_for_pending_exc;
  D.27691 = callinfo->func;
  D.27692 = callinfo->sig;
  wrapper = mono_marshal_get_icall_wrapper (D.27692, name, D.27691, check_for_pending_exc.53);
  monoeg_g_free (name);
  if (do_compile != 0) goto <D.27693>; else goto <D.27694>;
  <D.27693>:
  trampoline = mono_compile_method (wrapper);
  goto <D.27695>;
  <D.27694>:
  D.27696 = mono_create_jit_trampoline_in_domain (domain, wrapper);
  trampoline = mono_create_ftnptr (domain, D.27696);
  <D.27695>:
  mono_register_jit_icall_wrapper (callinfo, trampoline);
  callinfo->trampoline = trampoline;
  {
    int ret;

    D.27672 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27672);
    if (ret != 0) goto <D.27697>; else goto <D.27698>;
    <D.27697>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27698>:
    D.27699 = ret != 0;
    D.27700 = (long int) D.27699;
    D.27701 = __builtin_expect (D.27700, 0);
    if (D.27701 != 0) goto <D.27702>; else goto <D.27703>;
    <D.27702>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1717, "ret == 0");
    <D.27703>:
  }
  mono_loader_unlock ();
  D.27668 = callinfo->trampoline;
  return D.27668;
}


mono_allocate_stack_slots (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  unsigned int D.27705;
  struct MonoMethodVar * D.27708;
  struct MonoLiveInterval * D.27709;
  gint32 * D.27712;
  struct MonoMemPool * D.27713;
  unsigned int D.27714;
  unsigned int i.54;
  unsigned int D.27716;
  gint32 * D.27717;
  unsigned int i.55;
  unsigned int D.27719;
  struct MonoInst * * D.27720;
  struct MonoInst * * D.27721;
  unsigned int D.27722;
  unsigned char D.27725;
  int D.27726;
  int D.27727;
  short unsigned int D.27729;
  unsigned int D.27731;
  unsigned int D.27732;
  struct MonoInst * * D.27733;
  struct MonoType * D.27734;
  int D.27735;
  int D.27738;
  int D.27743;
  int D.27745;
  unsigned char D.27747;
  struct MonoClass * D.27749;
  int ialign.56;
  unsigned int ialign.57;
  struct MonoClass * D.27752;
  unsigned char D.27753;
  unsigned int D.27756;
  unsigned int D.27757;
  struct MonoClass * D.27760;
  unsigned char D.27761;
  unsigned char D.27762;
  unsigned char D.27765;
  unsigned char D.27766;
  unsigned char D.27769;
  unsigned char D.27770;
  int D.27774;
  int D.27775;
  unsigned int D.27778;
  unsigned int D.27779;
  struct MonoClass * D.27782;
  unsigned int D.27783;
  struct StackSlotInfo * D.27784;
  struct MonoClass * D.27785;
  _Bool D.27790;
  long int D.27791;
  long int D.27792;
  unsigned int nvtypes.58;
  unsigned int D.27796;
  struct StackSlotInfo * D.27797;
  unsigned char D.27798;
  unsigned char D.27801;
  unsigned int D.27806;
  unsigned int D.27807;
  struct GList * D.27810;
  unsigned int D.27811;
  unsigned int D.27812;
  struct GList * D.27814;
  unsigned int D.27815;
  unsigned int D.27816;
  gint32 * D.27817;
  int D.27818;
  void * D.27819;
  struct GSList * D.27820;
  struct GSList * D.27821;
  int D.27822;
  void * D.27827;
  struct GSList * D.27828;
  struct GList * D.27829;
  int count.59;
  int count.60;
  int D.27832;
  int D.27839;
  unsigned int align.61;
  unsigned int align.62;
  guint32 iftmp.63;
  struct MonoClass * D.27845;
  int D.27846;
  unsigned int D.27847;
  struct MonoClass * D.27850;
  int D.27851;
  unsigned int size.64;
  unsigned int D.27854;
  unsigned int D.27855;
  unsigned int D.27856;
  unsigned int D.27857;
  unsigned int offset.65;
  unsigned int D.27861;
  unsigned int D.27862;
  unsigned int D.27863;
  unsigned int D.27865;
  unsigned int D.27866;
  gint32 * D.27867;
  struct StackSlotInfo * D.27868;
  struct GList * D.27869;
  struct GList * D.27872;
  int D.27875;
  int D.27876;
  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.27705 = cfg->num_varinfo;
      if (D.27705 != 0) goto <D.27706>; else goto <D.27707>;
      <D.27706>:
      D.27708 = cfg->vars;
      D.27709 = D.27708->interval;
      if (D.27709 != 0B) goto <D.27710>; else goto <D.27711>;
      <D.27710>:
      D.27712 = mono_allocate_stack_slots2 (cfg, backward, stack_size, stack_align);
      return D.27712;
      <D.27711>:
      <D.27707>:
      D.27713 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.27713, 1104);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.27705 = cfg->num_varinfo;
      D.27714 = D.27705 * 4;
      D.27713 = cfg->mempool;
      offsets = mono_mempool_alloc (D.27713, D.27714);
      i = 0;
      goto <D.25187>;
      <D.25186>:
      i.54 = (unsigned int) i;
      D.27716 = i.54 * 4;
      D.27717 = offsets + D.27716;
      *D.27717 = -1;
      i = i + 1;
      <D.25187>:
      i.55 = (unsigned int) i;
      D.27705 = cfg->num_varinfo;
      if (i.55 < D.27705) goto <D.25186>; else goto <D.25188>;
      <D.25188>:
      D.27719 = cfg->locals_start;
      i = (int) D.27719;
      goto <D.25191>;
      <D.25190>:
      D.27720 = cfg->varinfo;
      i.54 = (unsigned int) i;
      D.27716 = i.54 * 4;
      D.27721 = D.27720 + D.27716;
      inst = *D.27721;
      D.27708 = cfg->vars;
      i.54 = (unsigned int) i;
      D.27722 = i.54 * 56;
      vmv = D.27708 + D.27722;
      D.27725 = inst->flags;
      D.27726 = (int) D.27725;
      D.27727 = D.27726 & 2;
      if (D.27727 != 0) goto <D.27723>; else goto <D.27728>;
      <D.27728>:
      D.27729 = inst->opcode;
      if (D.27729 == 366) goto <D.27723>; else goto <D.27730>;
      <D.27730>:
      D.27729 = inst->opcode;
      if (D.27729 == 367) goto <D.27723>; else goto <D.27724>;
      <D.27723>:
      // predicted unlikely by continue predictor.
      goto <D.25189>;
      <D.27724>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.25189>:
      i = i + 1;
      <D.25191>:
      i.55 = (unsigned int) i;
      D.27705 = cfg->num_varinfo;
      if (i.55 < D.27705) goto <D.25190>; else goto <D.25192>;
      <D.25192>:
      vars = mono_varlist_sort (cfg, vars, 0);
      offset = 0;
      *stack_align = 4;
      l = vars;
      goto <D.25219>;
      <D.25218>:
      vmv = l->data;
      D.27720 = cfg->varinfo;
      D.27731 = vmv->idx;
      D.27732 = D.27731 * 4;
      D.27733 = D.27720 + D.27732;
      inst = *D.27733;
      D.27734 = inst->data.op[1].vtype;
      t = mono_type_get_underlying_type (D.27734);
      D.27735 = cfg->gsharedvt;
      if (D.27735 != 0) goto <D.27736>; else goto <D.27737>;
      <D.27736>:
      D.27738 = mini_is_gsharedvt_variable_type (cfg, t);
      if (D.27738 != 0) goto <D.27739>; else goto <D.27740>;
      <D.27739>:
      // predicted unlikely by continue predictor.
      goto <D.25193>;
      <D.27740>:
      <D.27737>:
      D.27743 = inst->backend.is_pinvoke;
      if (D.27743 != 0) goto <D.27744>; else goto <D.27741>;
      <D.27744>:
      D.27745 = mono_type_is_struct (t);
      if (D.27745 != 0) goto <D.27746>; else goto <D.27741>;
      <D.27746>:
      D.27747 = t->type;
      if (D.27747 != 22) goto <D.27748>; else goto <D.27741>;
      <D.27748>:
      D.27749 = mono_class_from_mono_type (t);
      size = mono_class_native_size (D.27749, &align);
      goto <D.27742>;
      <D.27741>:
      {
        int ialign;

        try
          {
            size = mono_type_size (t, &ialign);
            ialign.56 = ialign;
            ialign.57 = (unsigned int) ialign.56;
            align = ialign.57;
            D.27752 = mono_class_from_mono_type (t);
            D.27753 = D.27752->exception_type;
            if (D.27753 != 0) goto <D.27754>; else goto <D.27755>;
            <D.27754>:
            mono_cfg_set_exception (cfg, 7);
            <D.27755>:
            D.27756 = cfg->opt;
            D.27757 = D.27756 & 67108864;
            if (D.27757 != 0) goto <D.27758>; else goto <D.27759>;
            <D.27758>:
            D.27760 = mono_class_from_mono_type (t);
            D.27761 = BIT_FIELD_REF <*D.27760, 8, 192>;
            D.27762 = D.27761 & 2;
            if (D.27762 != 0) goto <D.27763>; else goto <D.27764>;
            <D.27763>:
            align = 16;
            <D.27764>:
            <D.27759>:
          }
        finally
          {
            ialign = {CLOBBER};
          }
      }
      <D.27742>:
      reuse_slot = 1;
      D.27765 = BIT_FIELD_REF <*cfg, 8, 3408>;
      D.27766 = D.27765 & 1;
      if (D.27766 != 0) goto <D.27767>; else goto <D.27768>;
      <D.27767>:
      reuse_slot = 0;
      <D.27768>:
      D.27769 = BIT_FIELD_REF <*t, 8, 56>;
      D.27770 = D.27769 & 64;
      if (D.27770 != 0) goto <D.27771>; else goto <D.27772>;
      <D.27771>:
      slot_info = scalar_stack_slots + 384;
      goto <D.27773>;
      <D.27772>:
      D.27747 = t->type;
      D.27774 = (int) D.27747;
      switch (D.27774) <default: <D.25212>, case 8: <D.25204>, case 14: <D.25209>, case 15: <D.25201>, case 17: <D.25197>, case 18: <D.25205>, case 19: <D.25210>, case 20: <D.25207>, case 21: <D.25195>, case 24: <D.25202>, case 25: <D.25203>, case 28: <D.25206>, case 29: <D.25208>, case 30: <D.25211>>
      <D.25195>:
      D.27775 = mono_type_generic_inst_is_valuetype (t);
      if (D.27775 == 0) goto <D.27776>; else goto <D.27777>;
      <D.27776>:
      D.27747 = t->type;
      D.27778 = (unsigned int) D.27747;
      D.27779 = D.27778 * 16;
      slot_info = scalar_stack_slots + D.27779;
      goto <D.25196>;
      <D.27777>:
      <D.25197>:
      if (vtype_stack_slots == 0B) goto <D.27780>; else goto <D.27781>;
      <D.27780>:
      D.27713 = cfg->mempool;
      vtype_stack_slots = mono_mempool_alloc0 (D.27713, 4096);
      <D.27781>:
      i = 0;
      goto <D.25200>;
      <D.25199>:
      D.27782 = t->data.klass;
      i.54 = (unsigned int) i;
      D.27783 = i.54 * 16;
      D.27784 = vtype_stack_slots + D.27783;
      D.27785 = D.27784->vtype;
      if (D.27782 == D.27785) goto <D.25198>; else goto <D.27786>;
      <D.27786>:
      i = i + 1;
      <D.25200>:
      if (i < nvtypes) goto <D.25199>; else goto <D.25198>;
      <D.25198>:
      if (i < nvtypes) goto <D.27787>; else goto <D.27788>;
      <D.27787>:
      i.54 = (unsigned int) i;
      D.27783 = i.54 * 16;
      slot_info = vtype_stack_slots + D.27783;
      goto <D.27789>;
      <D.27788>:
      D.27790 = nvtypes > 255;
      D.27791 = (long int) D.27790;
      D.27792 = __builtin_expect (D.27791, 0);
      if (D.27792 != 0) goto <D.27793>; else goto <D.27794>;
      <D.27793>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2176, "nvtypes < 256");
      <D.27794>:
      nvtypes.58 = (unsigned int) nvtypes;
      D.27796 = nvtypes.58 * 16;
      D.27797 = vtype_stack_slots + D.27796;
      D.27782 = t->data.klass;
      D.27797->vtype = D.27782;
      nvtypes.58 = (unsigned int) nvtypes;
      D.27796 = nvtypes.58 * 16;
      slot_info = vtype_stack_slots + D.27796;
      nvtypes = nvtypes + 1;
      <D.27789>:
      D.27765 = BIT_FIELD_REF <*cfg, 8, 3408>;
      D.27798 = D.27765 & 2;
      if (D.27798 != 0) goto <D.27799>; else goto <D.27800>;
      <D.27799>:
      reuse_slot = 0;
      <D.27800>:
      goto <D.25196>;
      <D.25201>:
      <D.25202>:
      <D.25203>:
      <D.25204>:
      D.27765 = BIT_FIELD_REF <*cfg, 8, 3408>;
      D.27801 = D.27765 & 4;
      if (D.27801 != 0) goto <D.27802>; else goto <D.27803>;
      <D.27802>:
      slot_info = scalar_stack_slots + 384;
      goto <D.25196>;
      <D.27803>:
      <D.25205>:
      <D.25206>:
      <D.25207>:
      <D.25208>:
      <D.25209>:
      slot_info = scalar_stack_slots + 288;
      D.27765 = BIT_FIELD_REF <*cfg, 8, 3408>;
      D.27798 = D.27765 & 2;
      if (D.27798 != 0) goto <D.27804>; else goto <D.27805>;
      <D.27804>:
      reuse_slot = 0;
      <D.27805>:
      goto <D.25196>;
      <D.25210>:
      <D.25211>:
      D.27747 = t->type;
      D.27778 = (unsigned int) D.27747;
      D.27779 = D.27778 * 16;
      slot_info = scalar_stack_slots + D.27779;
      goto <D.25196>;
      <D.25212>:
      D.27747 = t->type;
      D.27778 = (unsigned int) D.27747;
      D.27779 = D.27778 * 16;
      slot_info = scalar_stack_slots + D.27779;
      goto <D.25196>;
      <D.25196>:
      <D.27773>:
      slot = 16777215;
      D.27806 = cfg->comp_done;
      D.27807 = D.27806 & 16;
      if (D.27807 != 0) goto <D.27808>; else goto <D.27809>;
      <D.27808>:
      goto <D.25216>;
      <D.25215>:
      {
        struct MonoMethodVar * amv;

        D.27810 = slot_info->active;
        amv = D.27810->data;
        D.27811 = amv->range.last_use.abs_pos;
        D.27812 = vmv->range.first_use.abs_pos;
        if (D.27811 > D.27812) goto <D.25214>; else goto <D.27813>;
        <D.27813>:
        D.27810 = slot_info->active;
        D.27810 = slot_info->active;
        D.27814 = monoeg_g_list_delete_link (D.27810, D.27810);
        slot_info->active = D.27814;
        D.27815 = amv->idx;
        D.27816 = D.27815 * 4;
        D.27817 = offsets + D.27816;
        D.27818 = *D.27817;
        D.27819 = (void *) D.27818;
        D.27820 = slot_info->slots;
        D.27713 = cfg->mempool;
        D.27821 = g_slist_prepend_mempool (D.27713, D.27820, D.27819);
        slot_info->slots = D.27821;
      }
      <D.25216>:
      D.27810 = slot_info->active;
      if (D.27810 != 0B) goto <D.25215>; else goto <D.25214>;
      <D.25214>:
      D.27725 = inst->flags;
      D.27726 = (int) D.27725;
      D.27822 = D.27726 & 20;
      if (D.27822 == 0) goto <D.27823>; else goto <D.27824>;
      <D.27823>:
      D.27820 = slot_info->slots;
      if (D.27820 != 0B) goto <D.27825>; else goto <D.27826>;
      <D.27825>:
      D.27820 = slot_info->slots;
      D.27827 = D.27820->data;
      slot = (int) D.27827;
      D.27820 = slot_info->slots;
      D.27828 = D.27820->next;
      slot_info->slots = D.27828;
      <D.27826>:
      D.27810 = slot_info->active;
      D.27829 = mono_varlist_insert_sorted (cfg, D.27810, vmv, 1);
      slot_info->active = D.27829;
      <D.27824>:
      <D.27809>:
      {
        static int count = 0;

        count.59 = count;
        count.60 = count.59 + 1;
        count = count.60;
      }
      D.27725 = inst->flags;
      D.27726 = (int) D.27725;
      D.27832 = D.27726 & 32;
      if (D.27832 != 0) goto <D.27833>; else goto <D.27834>;
      <D.27833>:
      size = 36;
      align = 4;
      reuse_slot = 0;
      <D.27834>:
      if (reuse_slot == 0) goto <D.27835>; else goto <D.27836>;
      <D.27835>:
      slot = 16777215;
      <D.27836>:
      if (slot == 16777215) goto <D.27837>; else goto <D.27838>;
      <D.27837>:
      D.27839 = mono_type_is_struct (t);
      if (D.27839 != 0) goto <D.27840>; else goto <D.27841>;
      <D.27840>:
      align.61 = align;
      align.62 = MAX_EXPR <align.61, 4>;
      align = align.62;
      D.27845 = mono_class_from_mono_type (t);
      D.27846 = mono_class_min_align (D.27845);
      D.27847 = (unsigned int) D.27846;
      align.61 = align;
      if (D.27847 >= align.61) goto <D.27848>; else goto <D.27849>;
      <D.27848>:
      D.27850 = mono_class_from_mono_type (t);
      D.27851 = mono_class_min_align (D.27850);
      iftmp.63 = (guint32) D.27851;
      goto <D.27852>;
      <D.27849>:
      iftmp.63 = align;
      <D.27852>:
      align = iftmp.63;
      align.61 = align;
      size.64 = (unsigned int) size;
      D.27854 = align.61 + size.64;
      D.27855 = D.27854 + 4294967295;
      align.61 = align;
      D.27856 = -align.61;
      D.27857 = D.27855 & D.27856;
      size = (int) D.27857;
      <D.27841>:
      if (backward != 0) goto <D.27858>; else goto <D.27859>;
      <D.27858>:
      offset = offset + size;
      align.61 = align;
      offset.65 = (unsigned int) offset;
      D.27861 = align.61 + offset.65;
      D.27862 = D.27861 + 4294967295;
      offset = (int) D.27862;
      align.61 = align;
      D.27856 = -align.61;
      offset.65 = (unsigned int) offset;
      D.27863 = D.27856 & offset.65;
      offset = (int) D.27863;
      slot = offset;
      goto <D.27864>;
      <D.27859>:
      align.61 = align;
      offset.65 = (unsigned int) offset;
      D.27861 = align.61 + offset.65;
      D.27862 = D.27861 + 4294967295;
      offset = (int) D.27862;
      align.61 = align;
      D.27856 = -align.61;
      offset.65 = (unsigned int) offset;
      D.27863 = D.27856 & offset.65;
      offset = (int) D.27863;
      slot = offset;
      offset = offset + size;
      <D.27864>:
      D.27865 = *stack_align;
      align.61 = align;
      D.27866 = MAX_EXPR <D.27865, align.61>;
      *stack_align = D.27866;
      <D.27838>:
      D.27731 = vmv->idx;
      D.27732 = D.27731 * 4;
      D.27867 = offsets + D.27732;
      *D.27867 = slot;
      <D.25193>:
      l = l->next;
      <D.25219>:
      if (l != 0B) goto <D.25218>; else goto <D.25220>;
      <D.25220>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.25222>;
      <D.25221>:
      i.54 = (unsigned int) i;
      D.27783 = i.54 * 16;
      D.27868 = scalar_stack_slots + D.27783;
      D.27869 = D.27868->active;
      if (D.27869 != 0B) goto <D.27870>; else goto <D.27871>;
      <D.27870>:
      i.54 = (unsigned int) i;
      D.27783 = i.54 * 16;
      D.27868 = scalar_stack_slots + D.27783;
      D.27869 = D.27868->active;
      monoeg_g_list_free (D.27869);
      <D.27871>:
      i = i + 1;
      <D.25222>:
      if (i <= 68) goto <D.25221>; else goto <D.25223>;
      <D.25223>:
      i = 0;
      goto <D.25225>;
      <D.25224>:
      i.54 = (unsigned int) i;
      D.27783 = i.54 * 16;
      D.27784 = vtype_stack_slots + D.27783;
      D.27872 = D.27784->active;
      if (D.27872 != 0B) goto <D.27873>; else goto <D.27874>;
      <D.27873>:
      i.54 = (unsigned int) i;
      D.27783 = i.54 * 16;
      D.27784 = vtype_stack_slots + D.27783;
      D.27872 = D.27784->active;
      monoeg_g_list_free (D.27872);
      <D.27874>:
      i = i + 1;
      <D.25225>:
      if (i < nvtypes) goto <D.25224>; else goto <D.25226>;
      <D.25226>:
      D.27875 = cfg->stat_locals_stack_size;
      D.27876 = D.27875 + offset;
      cfg->stat_locals_stack_size = D.27876;
      offset.65 = (unsigned int) offset;
      *stack_size = offset.65;
      D.27712 = offsets;
      return D.27712;
    }
  finally
    {
      align = {CLOBBER};
    }
}


mono_allocate_stack_slots2 (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  struct MonoMemPool * D.27879;
  unsigned int D.27880;
  unsigned int D.27881;
  unsigned int i.66;
  unsigned int D.27883;
  gint32 * D.27884;
  unsigned int i.67;
  unsigned int D.27886;
  struct MonoInst * * D.27887;
  struct MonoInst * * D.27888;
  struct MonoMethodVar * D.27889;
  unsigned int D.27890;
  unsigned char D.27893;
  int D.27894;
  int D.27895;
  short unsigned int D.27897;
  struct GList * D.27899;
  unsigned int D.27900;
  unsigned int D.27901;
  struct MonoInst * * D.27902;
  struct MonoType * D.27903;
  int D.27904;
  int D.27907;
  int D.27912;
  int D.27914;
  unsigned char D.27916;
  struct MonoClass * D.27918;
  int ialign.68;
  unsigned int ialign.69;
  unsigned int D.27921;
  unsigned int D.27922;
  struct MonoClass * D.27925;
  unsigned char D.27926;
  unsigned char D.27927;
  unsigned char D.27930;
  unsigned char D.27931;
  int D.27934;
  int D.27935;
  unsigned int D.27938;
  unsigned int D.27939;
  struct MonoClass * D.27942;
  unsigned int D.27943;
  struct StackSlotInfo * D.27944;
  struct MonoClass * D.27945;
  _Bool D.27950;
  long int D.27951;
  long int D.27952;
  unsigned int nvtypes.70;
  unsigned int D.27956;
  struct StackSlotInfo * D.27957;
  unsigned char D.27958;
  unsigned char D.27961;
  unsigned int D.27966;
  unsigned int D.27967;
  struct MonoLiveInterval * D.27970;
  struct MonoLiveRange2 * D.27971;
  int D.27974;
  unsigned char D.27978;
  struct MonoLiveInterval * D.27982;
  struct MonoLiveRange2 * D.27983;
  int D.27984;
  struct GList * D.27987;
  struct GList * D.27988;
  unsigned int D.27989;
  unsigned int D.27990;
  gint32 * D.27991;
  int D.27992;
  void * D.27993;
  struct GSList * D.27994;
  struct GSList * D.27995;
  int D.27996;
  struct GList * D.27999;
  struct GList * D.28000;
  struct GList * D.28001;
  struct MonoLiveInterval * D.28002;
  struct MonoLiveRange2 * D.28003;
  int D.28004;
  struct GList * D.28007;
  int D.28008;
  struct GList * D.28011;
  struct GList * D.28012;
  void * D.28017;
  struct GSList * D.28018;
  struct GList * D.28019;
  int D.28020;
  int D.28027;
  unsigned int align.71;
  unsigned int align.72;
  guint32 iftmp.73;
  struct MonoClass * D.28033;
  int D.28034;
  unsigned int D.28035;
  struct MonoClass * D.28038;
  int D.28039;
  unsigned int offset.74;
  unsigned int D.28044;
  unsigned int D.28045;
  unsigned int D.28046;
  unsigned int D.28047;
  unsigned int D.28049;
  gint32 * D.28052;
  struct StackSlotInfo * D.28053;
  struct GList * D.28054;
  struct GList * D.28057;
  int D.28060;
  int D.28061;
  gint32 * D.28062;
  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.27879 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.27879, 1104);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.27880 = cfg->num_varinfo;
      D.27881 = D.27880 * 4;
      D.27879 = cfg->mempool;
      offsets = mono_mempool_alloc (D.27879, D.27881);
      i = 0;
      goto <D.25114>;
      <D.25113>:
      i.66 = (unsigned int) i;
      D.27883 = i.66 * 4;
      D.27884 = offsets + D.27883;
      *D.27884 = -1;
      i = i + 1;
      <D.25114>:
      i.67 = (unsigned int) i;
      D.27880 = cfg->num_varinfo;
      if (i.67 < D.27880) goto <D.25113>; else goto <D.25115>;
      <D.25115>:
      D.27886 = cfg->locals_start;
      i = (int) D.27886;
      goto <D.25118>;
      <D.25117>:
      D.27887 = cfg->varinfo;
      i.66 = (unsigned int) i;
      D.27883 = i.66 * 4;
      D.27888 = D.27887 + D.27883;
      inst = *D.27888;
      D.27889 = cfg->vars;
      i.66 = (unsigned int) i;
      D.27890 = i.66 * 56;
      vmv = D.27889 + D.27890;
      D.27893 = inst->flags;
      D.27894 = (int) D.27893;
      D.27895 = D.27894 & 2;
      if (D.27895 != 0) goto <D.27891>; else goto <D.27896>;
      <D.27896>:
      D.27897 = inst->opcode;
      if (D.27897 == 366) goto <D.27891>; else goto <D.27898>;
      <D.27898>:
      D.27897 = inst->opcode;
      if (D.27897 == 367) goto <D.27891>; else goto <D.27892>;
      <D.27891>:
      // predicted unlikely by continue predictor.
      goto <D.25116>;
      <D.27892>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.25116>:
      i = i + 1;
      <D.25118>:
      i.67 = (unsigned int) i;
      D.27880 = cfg->num_varinfo;
      if (i.67 < D.27880) goto <D.25117>; else goto <D.25119>;
      <D.25119>:
      D.27899 = monoeg_g_list_copy (vars);
      vars = monoeg_g_list_sort (D.27899, compare_by_interval_start_pos_func);
      offset = 0;
      *stack_align = 0;
      unhandled = vars;
      goto <D.25156>;
      <D.25155>:
      {
        struct MonoMethodVar * current;

        current = unhandled->data;
        vmv = current;
        D.27887 = cfg->varinfo;
        D.27900 = vmv->idx;
        D.27901 = D.27900 * 4;
        D.27902 = D.27887 + D.27901;
        inst = *D.27902;
        D.27903 = inst->data.op[1].vtype;
        t = mono_type_get_underlying_type (D.27903);
        D.27904 = cfg->gsharedvt;
        if (D.27904 != 0) goto <D.27905>; else goto <D.27906>;
        <D.27905>:
        D.27907 = mini_is_gsharedvt_variable_type (cfg, t);
        if (D.27907 != 0) goto <D.27908>; else goto <D.27909>;
        <D.27908>:
        // predicted unlikely by continue predictor.
        goto <D.25121>;
        <D.27909>:
        <D.27906>:
        D.27912 = inst->backend.is_pinvoke;
        if (D.27912 != 0) goto <D.27913>; else goto <D.27910>;
        <D.27913>:
        D.27914 = mono_type_is_struct (t);
        if (D.27914 != 0) goto <D.27915>; else goto <D.27910>;
        <D.27915>:
        D.27916 = t->type;
        if (D.27916 != 22) goto <D.27917>; else goto <D.27910>;
        <D.27917>:
        D.27918 = mono_class_from_mono_type (t);
        size = mono_class_native_size (D.27918, &align);
        goto <D.27911>;
        <D.27910>:
        {
          int ialign;

          try
            {
              size = mono_type_size (t, &ialign);
              ialign.68 = ialign;
              ialign.69 = (unsigned int) ialign.68;
              align = ialign.69;
              D.27921 = cfg->opt;
              D.27922 = D.27921 & 67108864;
              if (D.27922 != 0) goto <D.27923>; else goto <D.27924>;
              <D.27923>:
              D.27925 = mono_class_from_mono_type (t);
              D.27926 = BIT_FIELD_REF <*D.27925, 8, 192>;
              D.27927 = D.27926 & 2;
              if (D.27927 != 0) goto <D.27928>; else goto <D.27929>;
              <D.27928>:
              align = 16;
              <D.27929>:
              <D.27924>:
            }
          finally
            {
              ialign = {CLOBBER};
            }
        }
        <D.27911>:
        reuse_slot = 1;
        D.27930 = BIT_FIELD_REF <*cfg, 8, 3408>;
        D.27931 = D.27930 & 1;
        if (D.27931 != 0) goto <D.27932>; else goto <D.27933>;
        <D.27932>:
        reuse_slot = 0;
        <D.27933>:
        D.27916 = t->type;
        D.27934 = (int) D.27916;
        switch (D.27934) <default: <D.25138>, case 8: <D.25132>, case 14: <D.25137>, case 15: <D.25129>, case 17: <D.25125>, case 18: <D.25133>, case 20: <D.25135>, case 21: <D.25123>, case 24: <D.25130>, case 25: <D.25131>, case 28: <D.25134>, case 29: <D.25136>>
        <D.25123>:
        D.27935 = mono_type_generic_inst_is_valuetype (t);
        if (D.27935 == 0) goto <D.27936>; else goto <D.27937>;
        <D.27936>:
        D.27916 = t->type;
        D.27938 = (unsigned int) D.27916;
        D.27939 = D.27938 * 16;
        slot_info = scalar_stack_slots + D.27939;
        goto <D.25124>;
        <D.27937>:
        <D.25125>:
        if (vtype_stack_slots == 0B) goto <D.27940>; else goto <D.27941>;
        <D.27940>:
        D.27879 = cfg->mempool;
        vtype_stack_slots = mono_mempool_alloc0 (D.27879, 4096);
        <D.27941>:
        i = 0;
        goto <D.25128>;
        <D.25127>:
        D.27942 = t->data.klass;
        i.66 = (unsigned int) i;
        D.27943 = i.66 * 16;
        D.27944 = vtype_stack_slots + D.27943;
        D.27945 = D.27944->vtype;
        if (D.27942 == D.27945) goto <D.25126>; else goto <D.27946>;
        <D.27946>:
        i = i + 1;
        <D.25128>:
        if (i < nvtypes) goto <D.25127>; else goto <D.25126>;
        <D.25126>:
        if (i < nvtypes) goto <D.27947>; else goto <D.27948>;
        <D.27947>:
        i.66 = (unsigned int) i;
        D.27943 = i.66 * 16;
        slot_info = vtype_stack_slots + D.27943;
        goto <D.27949>;
        <D.27948>:
        D.27950 = nvtypes > 255;
        D.27951 = (long int) D.27950;
        D.27952 = __builtin_expect (D.27951, 0);
        if (D.27952 != 0) goto <D.27953>; else goto <D.27954>;
        <D.27953>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1875, "nvtypes < 256");
        <D.27954>:
        nvtypes.70 = (unsigned int) nvtypes;
        D.27956 = nvtypes.70 * 16;
        D.27957 = vtype_stack_slots + D.27956;
        D.27942 = t->data.klass;
        D.27957->vtype = D.27942;
        nvtypes.70 = (unsigned int) nvtypes;
        D.27956 = nvtypes.70 * 16;
        slot_info = vtype_stack_slots + D.27956;
        nvtypes = nvtypes + 1;
        <D.27949>:
        D.27930 = BIT_FIELD_REF <*cfg, 8, 3408>;
        D.27958 = D.27930 & 2;
        if (D.27958 != 0) goto <D.27959>; else goto <D.27960>;
        <D.27959>:
        reuse_slot = 0;
        <D.27960>:
        goto <D.25124>;
        <D.25129>:
        <D.25130>:
        <D.25131>:
        <D.25132>:
        D.27930 = BIT_FIELD_REF <*cfg, 8, 3408>;
        D.27961 = D.27930 & 4;
        if (D.27961 != 0) goto <D.27962>; else goto <D.27963>;
        <D.27962>:
        slot_info = scalar_stack_slots + 384;
        goto <D.25124>;
        <D.27963>:
        <D.25133>:
        <D.25134>:
        <D.25135>:
        <D.25136>:
        <D.25137>:
        slot_info = scalar_stack_slots + 288;
        D.27930 = BIT_FIELD_REF <*cfg, 8, 3408>;
        D.27958 = D.27930 & 2;
        if (D.27958 != 0) goto <D.27964>; else goto <D.27965>;
        <D.27964>:
        reuse_slot = 0;
        <D.27965>:
        goto <D.25124>;
        <D.25138>:
        D.27916 = t->type;
        D.27938 = (unsigned int) D.27916;
        D.27939 = D.27938 * 16;
        slot_info = scalar_stack_slots + D.27939;
        <D.25124>:
        slot = 16777215;
        D.27966 = cfg->comp_done;
        D.27967 = D.27966 & 16;
        if (D.27967 != 0) goto <D.27968>; else goto <D.27969>;
        <D.27968>:
        {
          int pos;
          gboolean changed;

          D.27970 = current->interval;
          D.27971 = D.27970->range;
          if (D.27971 == 0B) goto <D.27972>; else goto <D.27973>;
          <D.27972>:
          D.27893 = inst->flags;
          D.27894 = (int) D.27893;
          D.27974 = D.27894 & 20;
          if (D.27974 != 0) goto <D.27975>; else goto <D.27976>;
          <D.27975>:
          pos = -1;
          goto <D.27977>;
          <D.27976>:
          D.27893 = inst->flags;
          D.27978 = D.27893 | 2;
          inst->flags = D.27978;
          // predicted unlikely by continue predictor.
          goto <D.25121>;
          <D.27977>:
          goto <D.27979>;
          <D.27973>:
          D.27970 = current->interval;
          D.27971 = D.27970->range;
          pos = D.27971->from;
          <D.27979>:
          D.27970 = current->interval;
          D.27971 = D.27970->range;
          if (D.27971 != 0B) goto <D.27980>; else goto <D.27981>;
          <D.27980>:
          <D.27981>:
          changed = 1;
          goto <D.25146>;
          <D.25145>:
          changed = 0;
          l = slot_info->active;
          goto <D.25144>;
          <D.25143>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.27982 = v->interval;
            D.27983 = D.27982->last_range;
            D.27984 = D.27983->to;
            if (D.27984 < pos) goto <D.27985>; else goto <D.27986>;
            <D.27985>:
            D.27987 = slot_info->active;
            D.27988 = monoeg_g_list_delete_link (D.27987, l);
            slot_info->active = D.27988;
            D.27989 = v->idx;
            D.27990 = D.27989 * 4;
            D.27991 = offsets + D.27990;
            D.27992 = *D.27991;
            D.27993 = (void *) D.27992;
            D.27994 = slot_info->slots;
            D.27879 = cfg->mempool;
            D.27995 = g_slist_prepend_mempool (D.27879, D.27994, D.27993);
            slot_info->slots = D.27995;
            changed = 1;
            goto <D.25142>;
            <D.27986>:
            D.27982 = v->interval;
            D.27996 = mono_linterval_covers (D.27982, pos);
            if (D.27996 == 0) goto <D.27997>; else goto <D.27998>;
            <D.27997>:
            D.27999 = slot_info->inactive;
            D.28000 = monoeg_g_list_append (D.27999, v);
            slot_info->inactive = D.28000;
            D.27987 = slot_info->active;
            D.28001 = monoeg_g_list_delete_link (D.27987, l);
            slot_info->active = D.28001;
            changed = 1;
            goto <D.25142>;
            <D.27998>:
          }
          l = l->next;
          <D.25144>:
          if (l != 0B) goto <D.25143>; else goto <D.25142>;
          <D.25142>:
          <D.25146>:
          if (changed != 0) goto <D.25145>; else goto <D.25147>;
          <D.25147>:
          changed = 1;
          goto <D.25153>;
          <D.25152>:
          changed = 0;
          l = slot_info->inactive;
          goto <D.25151>;
          <D.25150>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.28002 = v->interval;
            D.28003 = D.28002->last_range;
            D.28004 = D.28003->to;
            if (D.28004 < pos) goto <D.28005>; else goto <D.28006>;
            <D.28005>:
            D.27999 = slot_info->inactive;
            D.28007 = monoeg_g_list_delete_link (D.27999, l);
            slot_info->inactive = D.28007;
            changed = 1;
            goto <D.25149>;
            <D.28006>:
            D.28002 = v->interval;
            D.28008 = mono_linterval_covers (D.28002, pos);
            if (D.28008 != 0) goto <D.28009>; else goto <D.28010>;
            <D.28009>:
            D.27987 = slot_info->active;
            D.28011 = monoeg_g_list_append (D.27987, v);
            slot_info->active = D.28011;
            D.27999 = slot_info->inactive;
            D.28012 = monoeg_g_list_delete_link (D.27999, l);
            slot_info->inactive = D.28012;
            changed = 1;
            goto <D.25149>;
            <D.28010>:
          }
          l = l->next;
          <D.25151>:
          if (l != 0B) goto <D.25150>; else goto <D.25149>;
          <D.25149>:
          <D.25153>:
          if (changed != 0) goto <D.25152>; else goto <D.25154>;
          <D.25154>:
          D.27893 = inst->flags;
          D.27894 = (int) D.27893;
          D.27974 = D.27894 & 20;
          if (D.27974 == 0) goto <D.28013>; else goto <D.28014>;
          <D.28013>:
          D.27994 = slot_info->slots;
          if (D.27994 != 0B) goto <D.28015>; else goto <D.28016>;
          <D.28015>:
          D.27994 = slot_info->slots;
          D.28017 = D.27994->data;
          slot = (int) D.28017;
          D.27994 = slot_info->slots;
          D.28018 = D.27994->next;
          slot_info->slots = D.28018;
          <D.28016>:
          D.27987 = slot_info->active;
          D.28019 = mono_varlist_insert_sorted (cfg, D.27987, vmv, 1);
          slot_info->active = D.28019;
          <D.28014>:
        }
        <D.27969>:
        D.27893 = inst->flags;
        D.27894 = (int) D.27893;
        D.28020 = D.27894 & 32;
        if (D.28020 != 0) goto <D.28021>; else goto <D.28022>;
        <D.28021>:
        size = 36;
        align = 4;
        reuse_slot = 0;
        <D.28022>:
        if (reuse_slot == 0) goto <D.28023>; else goto <D.28024>;
        <D.28023>:
        slot = 16777215;
        <D.28024>:
        if (slot == 16777215) goto <D.28025>; else goto <D.28026>;
        <D.28025>:
        D.28027 = mono_type_is_struct (t);
        if (D.28027 != 0) goto <D.28028>; else goto <D.28029>;
        <D.28028>:
        align.71 = align;
        align.72 = MAX_EXPR <align.71, 4>;
        align = align.72;
        D.28033 = mono_class_from_mono_type (t);
        D.28034 = mono_class_min_align (D.28033);
        D.28035 = (unsigned int) D.28034;
        align.71 = align;
        if (D.28035 >= align.71) goto <D.28036>; else goto <D.28037>;
        <D.28036>:
        D.28038 = mono_class_from_mono_type (t);
        D.28039 = mono_class_min_align (D.28038);
        iftmp.73 = (guint32) D.28039;
        goto <D.28040>;
        <D.28037>:
        iftmp.73 = align;
        <D.28040>:
        align = iftmp.73;
        <D.28029>:
        if (backward != 0) goto <D.28041>; else goto <D.28042>;
        <D.28041>:
        offset = offset + size;
        align.71 = align;
        offset.74 = (unsigned int) offset;
        D.28044 = align.71 + offset.74;
        D.28045 = D.28044 + 4294967295;
        offset = (int) D.28045;
        align.71 = align;
        D.28046 = -align.71;
        offset.74 = (unsigned int) offset;
        D.28047 = D.28046 & offset.74;
        offset = (int) D.28047;
        slot = offset;
        goto <D.28048>;
        <D.28042>:
        align.71 = align;
        offset.74 = (unsigned int) offset;
        D.28044 = align.71 + offset.74;
        D.28045 = D.28044 + 4294967295;
        offset = (int) D.28045;
        align.71 = align;
        D.28046 = -align.71;
        offset.74 = (unsigned int) offset;
        D.28047 = D.28046 & offset.74;
        offset = (int) D.28047;
        slot = offset;
        offset = offset + size;
        <D.28048>:
        D.28049 = *stack_align;
        if (D.28049 == 0) goto <D.28050>; else goto <D.28051>;
        <D.28050>:
        align.71 = align;
        *stack_align = align.71;
        <D.28051>:
        <D.28026>:
        D.27900 = vmv->idx;
        D.27901 = D.27900 * 4;
        D.28052 = offsets + D.27901;
        *D.28052 = slot;
      }
      <D.25121>:
      unhandled = unhandled->next;
      <D.25156>:
      if (unhandled != 0B) goto <D.25155>; else goto <D.25157>;
      <D.25157>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.25159>;
      <D.25158>:
      i.66 = (unsigned int) i;
      D.27943 = i.66 * 16;
      D.28053 = scalar_stack_slots + D.27943;
      D.28054 = D.28053->active;
      if (D.28054 != 0B) goto <D.28055>; else goto <D.28056>;
      <D.28055>:
      i.66 = (unsigned int) i;
      D.27943 = i.66 * 16;
      D.28053 = scalar_stack_slots + D.27943;
      D.28054 = D.28053->active;
      monoeg_g_list_free (D.28054);
      <D.28056>:
      i = i + 1;
      <D.25159>:
      if (i <= 68) goto <D.25158>; else goto <D.25160>;
      <D.25160>:
      i = 0;
      goto <D.25162>;
      <D.25161>:
      i.66 = (unsigned int) i;
      D.27943 = i.66 * 16;
      D.27944 = vtype_stack_slots + D.27943;
      D.28057 = D.27944->active;
      if (D.28057 != 0B) goto <D.28058>; else goto <D.28059>;
      <D.28058>:
      i.66 = (unsigned int) i;
      D.27943 = i.66 * 16;
      D.27944 = vtype_stack_slots + D.27943;
      D.28057 = D.27944->active;
      monoeg_g_list_free (D.28057);
      <D.28059>:
      i = i + 1;
      <D.25162>:
      if (i < nvtypes) goto <D.25161>; else goto <D.25163>;
      <D.25163>:
      D.28060 = cfg->stat_locals_stack_size;
      D.28061 = D.28060 + offset;
      cfg->stat_locals_stack_size = D.28061;
      offset.74 = (unsigned int) offset;
      *stack_size = offset.74;
      D.28062 = offsets;
      return D.28062;
    }
  finally
    {
      align = {CLOBBER};
    }
}


compare_by_interval_start_pos_func (const void * a, const void * b)
{
  gint D.28067;
  struct MonoLiveInterval * D.28069;
  struct MonoLiveRange2 * D.28070;
  struct MonoLiveInterval * D.28072;
  struct MonoLiveRange2 * D.28073;
  int D.28075;
  int D.28076;
  struct MonoMethodVar * v1;
  struct MonoMethodVar * v2;

  v1 = a;
  v2 = b;
  if (v1 == v2) goto <D.28065>; else goto <D.28066>;
  <D.28065>:
  D.28067 = 0;
  return D.28067;
  <D.28066>:
  D.28069 = v1->interval;
  D.28070 = D.28069->range;
  if (D.28070 != 0B) goto <D.28071>; else goto <D.28068>;
  <D.28071>:
  D.28072 = v2->interval;
  D.28073 = D.28072->range;
  if (D.28073 != 0B) goto <D.28074>; else goto <D.28068>;
  <D.28074>:
  D.28069 = v1->interval;
  D.28070 = D.28069->range;
  D.28075 = D.28070->from;
  D.28072 = v2->interval;
  D.28073 = D.28072->range;
  D.28076 = D.28073->from;
  D.28067 = D.28075 - D.28076;
  return D.28067;
  <D.28068>:
  D.28069 = v1->interval;
  D.28070 = D.28069->range;
  if (D.28070 != 0B) goto <D.28077>; else goto <D.28078>;
  <D.28077>:
  D.28067 = -1;
  return D.28067;
  <D.28078>:
  D.28067 = 1;
  return D.28067;
}


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

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


mono_find_jit_opcode_emulation (int opcode)
{
  unsigned int opcode.75;
  _Bool D.28083;
  long int D.28084;
  long int D.28085;
  int D.28088;
  unsigned char D.28089;
  int D.28090;
  int D.28091;
  int D.28092;
  int D.28093;
  short int * emul_opcode_opcodes.76;
  unsigned int i.77;
  unsigned int D.28098;
  short int * D.28099;
  short int D.28100;
  int D.28101;
  struct MonoJitICallInfo * D.28104;
  struct MonoJitICallInfo * * emul_opcode_map.78;
  unsigned int D.28106;
  struct MonoJitICallInfo * * D.28107;
  short int emul_opcode_num.79;
  int D.28109;

  opcode.75 = (unsigned int) opcode;
  D.28083 = opcode.75 > 1047;
  D.28084 = (long int) D.28083;
  D.28085 = __builtin_expect (D.28084, 0);
  if (D.28085 != 0) goto <D.28086>; else goto <D.28087>;
  <D.28086>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2356, "opcode >= 0 && opcode <= OP_LAST");
  <D.28087>:
  D.28088 = opcode >> 6;
  D.28089 = emul_opcode_hit_cache[D.28088];
  D.28090 = (int) D.28089;
  D.28091 = opcode & 7;
  D.28092 = D.28090 >> D.28091;
  D.28093 = D.28092 & 1;
  if (D.28093 != 0) goto <D.28094>; else goto <D.28095>;
  <D.28094>:
  {
    int i;

    i = 0;
    goto <D.25237>;
    <D.25236>:
    emul_opcode_opcodes.76 = emul_opcode_opcodes;
    i.77 = (unsigned int) i;
    D.28098 = i.77 * 2;
    D.28099 = emul_opcode_opcodes.76 + D.28098;
    D.28100 = *D.28099;
    D.28101 = (int) D.28100;
    if (D.28101 == opcode) goto <D.28102>; else goto <D.28103>;
    <D.28102>:
    emul_opcode_map.78 = emul_opcode_map;
    i.77 = (unsigned int) i;
    D.28106 = i.77 * 4;
    D.28107 = emul_opcode_map.78 + D.28106;
    D.28104 = *D.28107;
    return D.28104;
    <D.28103>:
    i = i + 1;
    <D.25237>:
    emul_opcode_num.79 = emul_opcode_num;
    D.28109 = (int) emul_opcode_num.79;
    if (D.28109 > i) goto <D.25236>; else goto <D.25238>;
    <D.25238>:
  }
  <D.28095>:
  D.28104 = 0B;
  return D.28104;
}


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

  D.28111 = bb->last_ins;
  if (D.28111 != 0B) goto <D.28112>; else goto <D.28113>;
  <D.28112>:
  D.28111 = bb->last_ins;
  D.28111->next = inst;
  D.28111 = bb->last_ins;
  inst->prev = D.28111;
  bb->last_ins = inst;
  goto <D.28114>;
  <D.28113>:
  bb->last_ins = inst;
  D.28111 = bb->last_ins;
  bb->code = D.28111;
  <D.28114>:
}


mono_bblock_insert_after_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.28119;
  struct MonoInst * D.28123;

  if (ins == 0B) goto <D.28115>; else goto <D.28116>;
  <D.28115>:
  ins = bb->code;
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  if (ins != 0B) goto <D.28117>; else goto <D.28118>;
  <D.28117>:
  ins->prev = ins_to_insert;
  <D.28118>:
  D.28119 = bb->last_ins;
  if (D.28119 == 0B) goto <D.28120>; else goto <D.28121>;
  <D.28120>:
  bb->last_ins = ins_to_insert;
  <D.28121>:
  goto <D.28122>;
  <D.28116>:
  D.28123 = ins->next;
  ins_to_insert->next = D.28123;
  D.28123 = ins->next;
  if (D.28123 != 0B) goto <D.28124>; else goto <D.28125>;
  <D.28124>:
  D.28123 = ins->next;
  D.28123->prev = ins_to_insert;
  <D.28125>:
  ins->next = ins_to_insert;
  ins_to_insert->prev = ins;
  D.28119 = bb->last_ins;
  if (D.28119 == ins) goto <D.28126>; else goto <D.28127>;
  <D.28126>:
  bb->last_ins = ins_to_insert;
  <D.28127>:
  <D.28122>:
}


mono_bblock_insert_before_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.28132;
  struct MonoInst * D.28136;
  struct MonoInst * D.28139;

  if (ins == 0B) goto <D.28128>; else goto <D.28129>;
  <D.28128>:
  ins = bb->code;
  if (ins != 0B) goto <D.28130>; else goto <D.28131>;
  <D.28130>:
  ins->prev = ins_to_insert;
  <D.28131>:
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  D.28132 = bb->last_ins;
  if (D.28132 == 0B) goto <D.28133>; else goto <D.28134>;
  <D.28133>:
  bb->last_ins = ins_to_insert;
  <D.28134>:
  goto <D.28135>;
  <D.28129>:
  D.28136 = ins->prev;
  if (D.28136 != 0B) goto <D.28137>; else goto <D.28138>;
  <D.28137>:
  D.28136 = ins->prev;
  D.28136->next = ins_to_insert;
  <D.28138>:
  D.28136 = ins->prev;
  ins_to_insert->prev = D.28136;
  ins->prev = ins_to_insert;
  ins_to_insert->next = ins;
  D.28139 = bb->code;
  if (D.28139 == ins) goto <D.28140>; else goto <D.28141>;
  <D.28140>:
  bb->code = ins_to_insert;
  <D.28141>:
  <D.28135>:
}


mono_verify_bblock (struct MonoBasicBlock * bb)
{
  struct MonoInst * D.28142;
  _Bool D.28143;
  long int D.28144;
  long int D.28145;
  struct MonoInst * D.28148;
  struct MonoInst * D.28151;
  _Bool D.28152;
  long int D.28153;
  long int D.28154;
  struct MonoInst * ins;
  struct MonoInst * prev;

  prev = 0B;
  ins = bb->code;
  goto <D.25305>;
  <D.25304>:
  D.28142 = ins->prev;
  D.28143 = D.28142 != prev;
  D.28144 = (long int) D.28143;
  D.28145 = __builtin_expect (D.28144, 0);
  if (D.28145 != 0) goto <D.28146>; else goto <D.28147>;
  <D.28146>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2550, "ins->prev == prev");
  <D.28147>:
  prev = ins;
  ins = ins->next;
  <D.25305>:
  if (ins != 0B) goto <D.25304>; else goto <D.25306>;
  <D.25306>:
  D.28148 = bb->last_ins;
  if (D.28148 != 0B) goto <D.28149>; else goto <D.28150>;
  <D.28149>:
  D.28148 = bb->last_ins;
  D.28151 = D.28148->next;
  D.28152 = D.28151 != 0B;
  D.28153 = (long int) D.28152;
  D.28154 = __builtin_expect (D.28153, 0);
  if (D.28154 != 0) goto <D.28155>; else goto <D.28156>;
  <D.28155>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2554, "!bb->last_ins->next");
  <D.28156>:
  <D.28150>:
}


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

  bb = cfg->bb_entry;
  goto <D.25312>;
  <D.25311>:
  mono_verify_bblock (bb);
  bb = bb->next_bb;
  <D.25312>:
  if (bb != 0B) goto <D.25311>; else goto <D.25313>;
  <D.25313>:
}


mono_destroy_compile (struct MonoCompile * cfg)
{
  struct MonoMethodHeader * D.28157;
  struct MonoRegState * D.28160;
  struct GHashTable * D.28163;
  struct GHashTable * D.28166;
  void * D.28169;
  struct GList * D.28170;
  struct GHashTable * D.28171;
  struct GHashTable * D.28172;
  struct MonoMemPool * D.28175;
  struct MonoInst * * D.28176;
  struct MonoMethodVar * D.28177;
  char * D.28178;
  struct GSList * l;

  D.28157 = cfg->header;
  if (D.28157 != 0B) goto <D.28158>; else goto <D.28159>;
  <D.28158>:
  D.28157 = cfg->header;
  mono_metadata_free_mh (D.28157);
  <D.28159>:
  mono_free_loop_info (cfg);
  D.28160 = cfg->rs;
  if (D.28160 != 0B) goto <D.28161>; else goto <D.28162>;
  <D.28161>:
  D.28160 = cfg->rs;
  mono_regstate_free (D.28160);
  <D.28162>:
  D.28163 = cfg->spvars;
  if (D.28163 != 0B) goto <D.28164>; else goto <D.28165>;
  <D.28164>:
  D.28163 = cfg->spvars;
  monoeg_g_hash_table_destroy (D.28163);
  <D.28165>:
  D.28166 = cfg->exvars;
  if (D.28166 != 0B) goto <D.28167>; else goto <D.28168>;
  <D.28167>:
  D.28166 = cfg->exvars;
  monoeg_g_hash_table_destroy (D.28166);
  <D.28168>:
  l = cfg->headers_to_free;
  goto <D.25319>;
  <D.25318>:
  D.28169 = l->data;
  mono_metadata_free_mh (D.28169);
  l = l->next;
  <D.25319>:
  if (l != 0B) goto <D.25318>; else goto <D.25320>;
  <D.25320>:
  D.28170 = cfg->ldstr_list;
  monoeg_g_list_free (D.28170);
  D.28171 = cfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.28171);
  D.28172 = cfg->abs_patches;
  if (D.28172 != 0B) goto <D.28173>; else goto <D.28174>;
  <D.28173>:
  D.28172 = cfg->abs_patches;
  monoeg_g_hash_table_destroy (D.28172);
  <D.28174>:
  D.28175 = cfg->mempool;
  mono_mempool_destroy (D.28175);
  mono_debug_free_method (cfg);
  D.28176 = cfg->varinfo;
  monoeg_g_free (D.28176);
  D.28177 = cfg->vars;
  monoeg_g_free (D.28177);
  D.28178 = cfg->exception_message;
  monoeg_g_free (D.28178);
  monoeg_g_free (cfg);
}


mono_get_jit_tls_key ()
{
  pthread_key_t D.28179;

  D.28179 = mono_jit_tls_id;
  return D.28179;
}


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

  __asm__("movl $mono_jit_tls@ntpoff, %0" : "=r" offset);
  D.28181 = offset;
  return D.28181;
}


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

  __asm__("movl $mono_lmf@ntpoff, %0" : "=r" offset);
  D.28183 = offset;
  return D.28183;
}


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

  __asm__("movl $mono_lmf_addr@ntpoff, %0" : "=r" offset);
  D.28185 = offset;
  return D.28185;
}


mono_get_lmf ()
{
  struct MonoLMF * D.28187;

  D.28187 = mono_lmf;
  return D.28187;
}


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

  D.28189 = mono_lmf_addr;
  return D.28189;
}


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

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


mono_jit_thread_attach (struct MonoDomain * domain)
{
  void * mono_lmf_addr.80;
  struct MonoInternalThread * D.28197;
  struct MonoDomain * D.28200;
  struct MonoDomain * iftmp.81;
  struct MonoDomain * orig;

  if (domain == 0B) goto <D.28192>; else goto <D.28193>;
  <D.28192>:
  domain = mono_get_root_domain ();
  <D.28193>:
  mono_lmf_addr.80 = mono_lmf_addr;
  if (mono_lmf_addr.80 == 0B) goto <D.28195>; else goto <D.28196>;
  <D.28195>:
  mono_thread_attach (domain);
  D.28197 = mono_thread_internal_current ();
  mono_thread_set_state (D.28197, 4);
  <D.28196>:
  orig = mono_domain_get ();
  if (orig != domain) goto <D.28198>; else goto <D.28199>;
  <D.28198>:
  mono_domain_set (domain, 1);
  <D.28199>:
  if (orig != domain) goto <D.28202>; else goto <D.28203>;
  <D.28202>:
  iftmp.81 = orig;
  goto <D.28204>;
  <D.28203>:
  iftmp.81 = 0B;
  <D.28204>:
  D.28200 = iftmp.81;
  return D.28200;
}


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


mini_get_tls_offset (MonoTlsKey key)
{
  _Bool D.28208;
  long int D.28209;
  long int D.28210;
  int D.28213;
  int offset;

  switch (key) <default: <D.25404>, case 0: <D.25398>, case 1: <D.25400>, case 2: <D.25401>, case 3: <D.25402>, case 8: <D.25403>>
  <D.25398>:
  offset = mono_thread_get_tls_offset ();
  goto <D.25399>;
  <D.25400>:
  offset = mono_get_jit_tls_offset ();
  goto <D.25399>;
  <D.25401>:
  offset = mono_domain_get_tls_offset ();
  goto <D.25399>;
  <D.25402>:
  offset = mono_get_lmf_tls_offset ();
  goto <D.25399>;
  <D.25403>:
  offset = mono_get_lmf_addr_tls_offset ();
  goto <D.25399>;
  <D.25404>:
  offset = mono_tls_key_get_offset (key);
  D.28208 = offset == -1;
  D.28209 = (long int) D.28208;
  D.28210 = __builtin_expect (D.28209, 0);
  if (D.28210 != 0) goto <D.28211>; else goto <D.28212>;
  <D.28211>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2929, "offset != -1");
  <D.28212>:
  goto <D.25399>;
  <D.25399>:
  D.28213 = offset;
  return D.28213;
}


mini_tls_get_supported (struct MonoCompile * cfg, MonoTlsKey key)
{
  int D.28215;
  gboolean D.28218;
  unsigned char D.28219;
  unsigned char D.28220;
  int D.28223;
  _Bool D.28224;

  D.28215 = mono_x86_have_tls_get ();
  if (D.28215 == 0) goto <D.28216>; else goto <D.28217>;
  <D.28216>:
  D.28218 = 0;
  return D.28218;
  <D.28217>:
  D.28219 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.28220 = D.28219 & 64;
  if (D.28220 != 0) goto <D.28221>; else goto <D.28222>;
  <D.28221>:
  D.28218 = 1;
  return D.28218;
  <D.28222>:
  D.28223 = mini_get_tls_offset (key);
  D.28224 = D.28223 != -1;
  D.28218 = (gboolean) D.28224;
  return D.28218;
}


mono_create_tls_get (struct MonoCompile * cfg, MonoTlsKey key)
{
  unsigned char D.28226;
  unsigned char D.28227;
  int D.28231;
  struct MonoMemPool * D.28236;
  int D.28237;
  struct MonoInst * D.28238;
  guint16 iftmp.82;
  int D.28243;
  int D.28244;
  const unsigned char * D.28245;
  int D.28248;
  struct MonoInst * D.28249;
  int D.28250;
  int D.28251;
  struct MonoInst * key.83;
  int D.28253;
  void * key.84;
  unsigned int D.28256;
  int D.28257;
  void * _offset.85;
  unsigned int D.28260;
  int D.28261;
  struct MonoBasicBlock * D.28262;
  struct MonoInst * D.28263;
  int D.28267;
  struct MonoInst * D.28268;
  int D.28269;
  int D.28270;
  unsigned int D.28271;
  int D.28272;
  int D.28273;
  struct MonoInst * D.28274;
  int D.28275;

  D.28226 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.28227 = D.28226 & 64;
  if (D.28227 != 0) goto <D.28228>; else goto <D.28229>;
  <D.28228>:
  D.28231 = mono_x86_have_tls_get ();
  if (D.28231 != 0) goto <D.28232>; else goto <D.28230>;
  <D.28232>:
  if (1 != 0) goto <D.28233>; else goto <D.28230>;
  <D.28233>:
  {
    struct MonoInst * ins;
    struct MonoInst * c;

    D.28226 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.28227 = D.28226 & 64;
    if (D.28227 != 0) goto <D.28234>; else goto <D.28235>;
    <D.28234>:
    D.28236 = cfg->mempool;
    c = mono_mempool_alloc (D.28236, 48);
    c->data.op[1].const_val = 0;
    D.28237 = c->data.op[1].const_val;
    c->data.op[0].const_val = D.28237;
    c->prev = 0B;
    D.28238 = c->prev;
    c->next = D.28238;
    D.28226 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.28227 = D.28226 & 64;
    if (D.28227 != 0) goto <D.28240>; else goto <D.28241>;
    <D.28240>:
    iftmp.82 = 738;
    goto <D.28242>;
    <D.28241>:
    iftmp.82 = 362;
    <D.28242>:
    c->opcode = iftmp.82;
    c->flags = 0;
    c->type = 0;
    c->dreg = -1;
    c->sreg3 = -1;
    D.28243 = c->sreg3;
    c->sreg2 = D.28243;
    D.28244 = c->sreg2;
    c->sreg1 = D.28244;
    D.28245 = cfg->ip;
    c->cil_code = D.28245;
    D.28226 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.28227 = D.28226 & 64;
    if (D.28227 != 0) goto <D.28246>; else goto <D.28247>;
    <D.28246>:
    {
      struct MonoInst * group;
      struct MonoInst * got_loc;

      got_loc = mono_get_got_var (cfg);
      D.28236 = cfg->mempool;
      group = mono_mempool_alloc (D.28236, 48);
      group->data.op[1].const_val = 0;
      D.28248 = group->data.op[1].const_val;
      group->data.op[0].const_val = D.28248;
      group->prev = 0B;
      D.28249 = group->prev;
      group->next = D.28249;
      group->opcode = 737;
      group->flags = 0;
      group->type = 0;
      group->dreg = -1;
      group->sreg3 = -1;
      D.28250 = group->sreg3;
      group->sreg2 = D.28250;
      D.28251 = group->sreg2;
      group->sreg1 = D.28251;
      D.28245 = cfg->ip;
      group->cil_code = D.28245;
      key.83 = (struct MonoInst *) key;
      group->data.op[0].src = key.83;
      group->data.op[1].src = 48B;
      D.28253 = got_loc->dreg;
      c->sreg1 = D.28253;
      c->data.op[1].p = group;
    }
    goto <D.28254>;
    <D.28247>:
    key.84 = (void *) key;
    c->data.op[0].p = key.84;
    c->data.op[1].src = 48B;
    <D.28254>:
    c->type = 3;
    D.28256 = alloc_dreg (cfg, 3);
    D.28257 = (int) D.28256;
    c->dreg = D.28257;
    goto <D.28258>;
    <D.28235>:
    {
      int _offset;

      _offset = mini_get_tls_offset (key);
      D.28236 = cfg->mempool;
      c = mono_mempool_alloc (D.28236, 48);
      c->data.op[1].const_val = 0;
      D.28237 = c->data.op[1].const_val;
      c->data.op[0].const_val = D.28237;
      c->prev = 0B;
      D.28238 = c->prev;
      c->next = D.28238;
      c->opcode = 362;
      c->flags = 0;
      c->type = 0;
      c->dreg = -1;
      c->sreg3 = -1;
      D.28243 = c->sreg3;
      c->sreg2 = D.28243;
      D.28244 = c->sreg2;
      c->sreg1 = D.28244;
      D.28245 = cfg->ip;
      c->cil_code = D.28245;
      _offset.85 = (void *) _offset;
      c->data.op[0].p = _offset.85;
      c->type = 3;
      D.28260 = alloc_dreg (cfg, 3);
      D.28261 = (int) D.28260;
      c->dreg = D.28261;
    }
    <D.28258>:
    D.28262 = cfg->cbb;
    D.28263 = D.28262->last_ins;
    if (D.28263 != 0B) goto <D.28264>; else goto <D.28265>;
    <D.28264>:
    D.28262 = cfg->cbb;
    D.28263 = D.28262->last_ins;
    D.28263->next = c;
    D.28262 = cfg->cbb;
    D.28263 = D.28262->last_ins;
    c->prev = D.28263;
    D.28262 = cfg->cbb;
    D.28262->last_ins = c;
    goto <D.28266>;
    <D.28265>:
    D.28262 = cfg->cbb;
    D.28262 = cfg->cbb;
    D.28262->last_ins = c;
    D.28263 = D.28262->last_ins;
    D.28262->code = D.28263;
    <D.28266>:
    D.28236 = cfg->mempool;
    ins = mono_mempool_alloc (D.28236, 48);
    ins->data.op[1].const_val = 0;
    D.28267 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.28267;
    ins->prev = 0B;
    D.28268 = ins->prev;
    ins->next = D.28268;
    ins->opcode = 796;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.28269 = ins->sreg3;
    ins->sreg2 = D.28269;
    D.28270 = ins->sreg2;
    ins->sreg1 = D.28270;
    D.28245 = cfg->ip;
    ins->cil_code = D.28245;
    D.28271 = mono_alloc_preg (cfg);
    D.28272 = (int) D.28271;
    ins->dreg = D.28272;
    D.28273 = c->dreg;
    ins->sreg1 = D.28273;
    D.28274 = ins;
    return D.28274;
  }
  <D.28230>:
  D.28274 = 0B;
  return D.28274;
  <D.28229>:
  D.28275 = mini_get_tls_offset (key);
  D.28274 = mono_create_tls_get_offset (cfg, D.28275);
  return D.28274;
}


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

  switch (stack_type) <default: <D.24240>, case 1: <D.24233>, case 2: <D.24238>, case 3: <D.24234>, case 4: <D.24237>, case 5: <D.24235>, case 6: <D.24236>, case 7: <D.24239>>
  <D.24233>:
  <D.24234>:
  D.28277 = alloc_ireg (cfg);
  return D.28277;
  <D.24235>:
  D.28277 = alloc_ireg_mp (cfg);
  return D.28277;
  <D.24236>:
  D.28277 = alloc_ireg_ref (cfg);
  return D.28277;
  <D.24237>:
  D.28277 = alloc_freg (cfg);
  return D.28277;
  <D.24238>:
  D.28277 = alloc_lreg (cfg);
  return D.28277;
  <D.24239>:
  D.28277 = alloc_ireg (cfg);
  return D.28277;
  <D.24240>:
  monoeg_g_log (0B, 16, "Unknown stack type %x\n", stack_type);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ir-emit.h", 97);
  D.28277 = 4294967295;
  return D.28277;
}


alloc_ireg_mp (struct MonoCompile * cfg)
{
  unsigned int D.28279;
  unsigned char D.28280;
  unsigned char D.28281;
  guint32 D.28284;
  int vreg;

  D.28279 = alloc_ireg (cfg);
  vreg = (int) D.28279;
  D.28280 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.28281 = D.28280 & 128;
  if (D.28281 != 0) goto <D.28282>; else goto <D.28283>;
  <D.28282>:
  mono_mark_vreg_as_mp (cfg, vreg);
  <D.28283>:
  D.28284 = (guint32) vreg;
  return D.28284;
}


alloc_ireg_ref (struct MonoCompile * cfg)
{
  unsigned int D.28286;
  unsigned char D.28287;
  unsigned char D.28288;
  guint32 D.28291;
  int vreg;

  D.28286 = alloc_ireg (cfg);
  vreg = (int) D.28286;
  D.28287 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.28288 = D.28287 & 128;
  if (D.28288 != 0) goto <D.28289>; else goto <D.28290>;
  <D.28289>:
  mono_mark_vreg_as_ref (cfg, vreg);
  <D.28290>:
  D.28291 = (guint32) vreg;
  return D.28291;
}


alloc_freg (struct MonoCompile * cfg)
{
  int D.28293;
  guint32 D.28296;
  unsigned int D.28297;
  unsigned int D.28298;
  unsigned int D.28299;

  D.28293 = mono_arch_is_soft_float ();
  if (D.28293 != 0) goto <D.28294>; else goto <D.28295>;
  <D.28294>:
  D.28296 = alloc_lreg (cfg);
  return D.28296;
  <D.28295>:
  D.28297 = cfg->next_vreg;
  D.28298 = D.28297;
  D.28299 = D.28298 + 1;
  cfg->next_vreg = D.28299;
  D.28296 = D.28298;
  return D.28296;
}


alloc_lreg (struct MonoCompile * cfg)
{
  unsigned int D.28301;
  unsigned int D.28302;
  guint32 D.28303;
  guint32 res;

  res = cfg->next_vreg;
  D.28301 = cfg->next_vreg;
  D.28302 = D.28301 + 3;
  cfg->next_vreg = D.28302;
  D.28303 = res;
  return D.28303;
}


alloc_ireg (struct MonoCompile * cfg)
{
  guint32 D.28305;
  unsigned int D.28306;
  unsigned int D.28307;
  unsigned int D.28308;

  D.28306 = cfg->next_vreg;
  D.28307 = D.28306;
  D.28308 = D.28307 + 1;
  cfg->next_vreg = D.28308;
  D.28305 = D.28307;
  return D.28305;
}


mono_create_tls_get_offset (struct MonoCompile * cfg, int offset)
{
  int D.28310;
  struct MonoInst * D.28313;
  struct MonoMemPool * D.28316;
  int D.28317;
  struct MonoInst * D.28318;
  int D.28319;
  int D.28320;
  const unsigned char * D.28321;
  unsigned int D.28322;
  int D.28323;
  struct MonoInst * ins;

  D.28310 = mono_x86_have_tls_get ();
  if (D.28310 == 0) goto <D.28311>; else goto <D.28312>;
  <D.28311>:
  D.28313 = 0B;
  return D.28313;
  <D.28312>:
  if (offset == -1) goto <D.28314>; else goto <D.28315>;
  <D.28314>:
  D.28313 = 0B;
  return D.28313;
  <D.28315>:
  D.28316 = cfg->mempool;
  ins = mono_mempool_alloc (D.28316, 48);
  ins->data.op[1].const_val = 0;
  D.28317 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.28317;
  ins->prev = 0B;
  D.28318 = ins->prev;
  ins->next = D.28318;
  ins->opcode = 795;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.28319 = ins->sreg3;
  ins->sreg2 = D.28319;
  D.28320 = ins->sreg2;
  ins->sreg1 = D.28320;
  D.28321 = cfg->ip;
  ins->cil_code = D.28321;
  D.28322 = mono_alloc_preg (cfg);
  D.28323 = (int) D.28322;
  ins->dreg = D.28323;
  ins->data.op[0].const_val = offset;
  D.28313 = ins;
  return D.28313;
}


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


mono_remove_patch_info (struct MonoCompile * cfg, int ip)
{
  struct MonoJumpInfo * D.28341;
  int D.28342;
  struct MonoJumpInfo * D.28345;
  struct MonoJumpInfo * * ji;

  ji = &cfg->patch_info;
  goto <D.25466>;
  <D.25465>:
  D.28341 = *ji;
  D.28342 = D.28341->ip.i;
  if (D.28342 == ip) goto <D.28343>; else goto <D.28344>;
  <D.28343>:
  D.28341 = *ji;
  D.28345 = D.28341->next;
  *ji = D.28345;
  goto <D.28346>;
  <D.28344>:
  D.28341 = *ji;
  ji = &D.28341->next;
  <D.28346>:
  <D.25466>:
  D.28341 = *ji;
  if (D.28341 != 0B) goto <D.25465>; else goto <D.25467>;
  <D.25467>:
}


mono_patch_info_dup_mp (struct MonoMemPool * mp, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.28347;
  void * D.28348;
  struct MonoJumpInfoToken * D.28349;
  struct MonoJumpInfoToken * D.28350;
  void * D.28351;
  struct MonoJumpInfoBBTable * D.28352;
  struct MonoJumpInfoBBTable * D.28353;
  int D.28354;
  unsigned int D.28355;
  unsigned int D.28356;
  void * D.28357;
  struct MonoBasicBlock * * D.28358;
  struct MonoBasicBlock * * D.28359;
  void * D.28360;
  struct MonoJumpInfoRgctxEntry * D.28361;
  struct MonoJumpInfoRgctxEntry * D.28362;
  struct MonoJumpInfo * D.28363;
  struct MonoJumpInfo * D.28364;
  void * D.28365;
  struct MonoJumpInfoGSharedVtCall * D.28366;
  struct MonoJumpInfoGSharedVtCall * D.28367;
  struct GPtrArray * D.28368;
  struct GPtrArray * D.28369;
  void * * D.28372;
  unsigned int i.86;
  unsigned int D.28374;
  void * * D.28375;
  struct GPtrArray * D.28376;
  unsigned int i.87;
  unsigned int D.28378;
  struct MonoJumpInfo * D.28379;
  struct MonoJumpInfo * res;

  res = mono_mempool_alloc (mp, 20);
  memcpy (res, patch_info, 20);
  D.28347 = patch_info->type;
  switch (D.28347) <default: <D.25491>, case 8: <D.25479>, case 17: <D.25474>, case 18: <D.25476>, case 19: <D.25475>, case 28: <D.25477>, case 29: <D.25473>, case 35: <D.25480>, case 45: <D.25481>, case 46: <D.25482>>
  <D.25473>:
  <D.25474>:
  <D.25475>:
  <D.25476>:
  <D.25477>:
  D.28348 = mono_mempool_alloc (mp, 20);
  res->data.token = D.28348;
  D.28349 = patch_info->data.token;
  D.28350 = res->data.token;
  memcpy (D.28350, D.28349, 20);
  goto <D.25478>;
  <D.25479>:
  D.28351 = mono_mempool_alloc (mp, 8);
  res->data.table = D.28351;
  D.28352 = patch_info->data.table;
  D.28353 = res->data.table;
  memcpy (D.28353, D.28352, 8);
  D.28353 = res->data.table;
  D.28352 = patch_info->data.table;
  D.28354 = D.28352->table_size;
  D.28355 = (unsigned int) D.28354;
  D.28356 = D.28355 * 4;
  D.28357 = mono_mempool_alloc (mp, D.28356);
  D.28353->table = D.28357;
  D.28352 = patch_info->data.table;
  D.28354 = D.28352->table_size;
  D.28355 = (unsigned int) D.28354;
  D.28356 = D.28355 * 4;
  D.28352 = patch_info->data.table;
  D.28358 = D.28352->table;
  D.28353 = res->data.table;
  D.28359 = D.28353->table;
  memcpy (D.28359, D.28358, D.28356);
  goto <D.25478>;
  <D.25480>:
  D.28360 = mono_mempool_alloc (mp, 16);
  res->data.rgctx_entry = D.28360;
  D.28361 = patch_info->data.rgctx_entry;
  D.28362 = res->data.rgctx_entry;
  memcpy (D.28362, D.28361, 16);
  D.28362 = res->data.rgctx_entry;
  D.28362 = res->data.rgctx_entry;
  D.28363 = D.28362->data;
  D.28364 = mono_patch_info_dup_mp (mp, D.28363);
  D.28362->data = D.28364;
  goto <D.25478>;
  <D.25481>:
  D.28365 = mono_mempool_alloc (mp, 8);
  res->data.gsharedvt = D.28365;
  D.28366 = patch_info->data.gsharedvt;
  D.28367 = res->data.gsharedvt;
  memcpy (D.28367, D.28366, 8);
  goto <D.25478>;
  <D.25482>:
  {
    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.28368 = monoeg_g_ptr_array_new ();
    info->entries = D.28368;
    D.28369 = oinfo->entries;
    if (D.28369 != 0B) goto <D.28370>; else goto <D.28371>;
    <D.28370>:
    i = 0;
    goto <D.25489>;
    <D.25488>:
    {
      struct MonoRuntimeGenericContextInfoTemplate * otemplate;
      struct MonoRuntimeGenericContextInfoTemplate * template;

      D.28369 = oinfo->entries;
      D.28372 = D.28369->pdata;
      i.86 = (unsigned int) i;
      D.28374 = i.86 * 4;
      D.28375 = D.28372 + D.28374;
      otemplate = *D.28375;
      template = mono_mempool_alloc0 (mp, 12);
      memcpy (template, otemplate, 12);
      D.28376 = info->entries;
      monoeg_g_ptr_array_add (D.28376, template);
    }
    i = i + 1;
    <D.25489>:
    i.87 = (unsigned int) i;
    D.28369 = oinfo->entries;
    D.28378 = D.28369->len;
    if (i.87 < D.28378) goto <D.25488>; else goto <D.25490>;
    <D.25490>:
    <D.28371>:
    goto <D.25478>;
  }
  <D.25491>:
  goto <D.25478>;
  <D.25478>:
  D.28379 = res;
  return D.28379;
}


mono_patch_info_hash (const void * data)
{
  <unnamed type> D.28382;
  guint D.28383;
  unsigned int D.28384;
  struct MonoJumpInfoToken * D.28385;
  unsigned int D.28386;
  unsigned int D.28387;
  unsigned int iftmp.88;
  int D.28389;
  struct MonoGenericInst * D.28392;
  const char * D.28394;
  unsigned int D.28395;
  const void * D.28396;
  unsigned int D.28397;
  struct MonoJumpInfoGSharedVtCall * D.28398;
  struct MonoMethod * D.28399;
  unsigned int D.28400;
  struct MonoMethod * D.28401;
  unsigned int D.28402;
  unsigned int D.28403;
  int D.28404;
  unsigned int D.28405;
  unsigned int D.28406;
  <unnamed type> D.28407;
  unsigned int D.28408;
  struct MonoJumpInfo * D.28409;
  unsigned int D.28410;
  struct MonoJumpInfoBBTable * D.28411;
  int D.28412;
  unsigned int D.28413;
  struct MonoGSharedVtMethodInfo * D.28414;
  struct MonoMethod * D.28415;
  unsigned int D.28416;
  const struct MonoJumpInfo * ji;

  ji = data;
  D.28382 = ji->type;
  switch (D.28382) <default: <D.25536>, case 3: <D.25509>, case 4: <D.25510>, case 6: <D.25508>, case 7: <D.25501>, case 8: <D.25533>, case 11: <D.25503>, case 12: <D.25511>, case 13: <D.25514>, case 14: <D.25502>, case 15: <D.25506>, case 16: <D.25515>, case 17: <D.25497>, case 18: <D.25498>, case 19: <D.25500>, case 23: <D.25504>, case 24: <D.25505>, case 27: <D.25532>, case 28: <D.25499>, case 29: <D.25496>, case 30: <D.25518>, case 31: <D.25513>, case 32: <D.25512>, case 33: <D.25525>, case 34: <D.25517>, case 35: <D.25523>, case 36: <D.25507>, case 37: <D.25529>, case 38: <D.25530>, case 39: <D.25526>, case 40: <D.25516>, case 42: <D.25527>, case 43: <D.25531>, case 44: <D.25519>, case 45: <D.25522>, case 46: <D.25534>, case 47: <D.25528>, case 48: <D.25520>, case 49: <D.25535>, case 50: <D.25521>>
  <D.25496>:
  <D.25497>:
  <D.25498>:
  <D.25499>:
  D.28382 = ji->type;
  D.28384 = D.28382 << 8;
  D.28385 = ji->data.token;
  D.28386 = D.28385->token;
  D.28383 = D.28384 | D.28386;
  return D.28383;
  <D.25500>:
  D.28382 = ji->type;
  D.28384 = D.28382 << 8;
  D.28385 = ji->data.token;
  D.28386 = D.28385->token;
  D.28387 = D.28384 | D.28386;
  D.28385 = ji->data.token;
  D.28389 = D.28385->has_context;
  if (D.28389 != 0) goto <D.28390>; else goto <D.28391>;
  <D.28390>:
  D.28385 = ji->data.token;
  D.28392 = D.28385->context.class_inst;
  iftmp.88 = (unsigned int) D.28392;
  goto <D.28393>;
  <D.28391>:
  iftmp.88 = 0;
  <D.28393>:
  D.28383 = D.28387 | iftmp.88;
  return D.28383;
  <D.25501>:
  D.28382 = ji->type;
  D.28384 = D.28382 << 8;
  D.28394 = ji->data.name;
  D.28395 = monoeg_g_str_hash (D.28394);
  D.28383 = D.28384 | D.28395;
  return D.28383;
  <D.25502>:
  <D.25503>:
  <D.25504>:
  <D.25505>:
  <D.25506>:
  <D.25507>:
  <D.25508>:
  <D.25509>:
  <D.25510>:
  <D.25511>:
  <D.25512>:
  <D.25513>:
  <D.25514>:
  <D.25515>:
  <D.25516>:
  <D.25517>:
  <D.25518>:
  <D.25519>:
  <D.25520>:
  <D.25521>:
  D.28382 = ji->type;
  D.28384 = D.28382 << 8;
  D.28396 = ji->data.target;
  D.28397 = (unsigned int) D.28396;
  D.28383 = D.28384 | D.28397;
  return D.28383;
  <D.25522>:
  D.28382 = ji->type;
  D.28384 = D.28382 << 8;
  D.28398 = ji->data.gsharedvt;
  D.28399 = D.28398->method;
  D.28400 = (unsigned int) D.28399;
  D.28383 = D.28384 | D.28400;
  return D.28383;
  <D.25523>:
  {
    struct MonoJumpInfoRgctxEntry * e;

    e = ji->data.rgctx_entry;
    D.28382 = ji->type;
    D.28384 = D.28382 << 8;
    D.28401 = e->method;
    D.28402 = (unsigned int) D.28401;
    D.28403 = D.28384 | D.28402;
    D.28404 = e->in_mrgctx;
    D.28405 = (unsigned int) D.28404;
    D.28406 = D.28403 | D.28405;
    D.28407 = e->info_type;
    D.28408 = D.28406 | D.28407;
    D.28409 = e->data;
    D.28410 = mono_patch_info_hash (D.28409);
    D.28383 = D.28408 | D.28410;
    return D.28383;
  }
  <D.25525>:
  <D.25526>:
  <D.25527>:
  <D.25528>:
  <D.25529>:
  <D.25530>:
  <D.25531>:
  <D.25532>:
  D.28382 = ji->type;
  D.28383 = D.28382 << 8;
  return D.28383;
  <D.25533>:
  D.28382 = ji->type;
  D.28384 = D.28382 << 8;
  D.28411 = ji->data.table;
  D.28412 = D.28411->table_size;
  D.28413 = (unsigned int) D.28412;
  D.28383 = D.28384 | D.28413;
  return D.28383;
  <D.25534>:
  D.28382 = ji->type;
  D.28384 = D.28382 << 8;
  D.28414 = ji->data.gsharedvt_method;
  D.28415 = D.28414->method;
  D.28416 = (unsigned int) D.28415;
  D.28383 = D.28384 | D.28416;
  return D.28383;
  <D.25535>:
  D.28396 = ji->data.target;
  D.28383 = monoeg_g_str_hash (D.28396);
  return D.28383;
  <D.25536>:
  D.28382 = ji->type;
  printf ("info type: %d\n", D.28382);
  mono_print_ji (ji);
  printf ("\n");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3203);
  D.28383 = 0;
  return D.28383;
}


mono_patch_info_equal (const void * ka, const void * kb)
{
  <unnamed type> D.28418;
  <unnamed type> D.28419;
  gint D.28422;
  struct MonoJumpInfoToken * D.28425;
  struct MonoImage * D.28426;
  struct MonoJumpInfoToken * D.28427;
  struct MonoImage * D.28428;
  unsigned int D.28430;
  unsigned int D.28431;
  int D.28433;
  int D.28434;
  struct MonoGenericInst * D.28436;
  struct MonoGenericInst * D.28437;
  struct MonoGenericInst * D.28439;
  struct MonoGenericInst * D.28440;
  const char * D.28441;
  const char * D.28442;
  int iftmp.89;
  struct MonoMethod * D.28446;
  struct MonoMethod * D.28447;
  int D.28449;
  int D.28450;
  <unnamed type> D.28452;
  <unnamed type> D.28453;
  struct MonoJumpInfo * D.28455;
  struct MonoJumpInfo * D.28456;
  int D.28457;
  int iftmp.90;
  struct MonoMethodSignature * D.28462;
  struct MonoMethodSignature * D.28463;
  struct MonoMethod * D.28465;
  struct MonoMethod * D.28466;
  struct MonoGSharedVtMethodInfo * D.28468;
  struct MonoMethod * D.28469;
  struct MonoGSharedVtMethodInfo * D.28470;
  struct MonoMethod * D.28471;
  _Bool D.28472;
  const void * D.28473;
  const void * D.28474;
  const struct MonoJumpInfo * ji1;
  const struct MonoJumpInfo * ji2;

  ji1 = ka;
  ji2 = kb;
  D.28418 = ji1->type;
  D.28419 = ji2->type;
  if (D.28418 != D.28419) goto <D.28420>; else goto <D.28421>;
  <D.28420>:
  D.28422 = 0;
  return D.28422;
  <D.28421>:
  D.28418 = ji1->type;
  switch (D.28418) <default: <D.25557>, case 7: <D.25549>, case 17: <D.25544>, case 18: <D.25546>, case 19: <D.25545>, case 28: <D.25547>, case 29: <D.25543>, case 35: <D.25550>, case 45: <D.25553>, case 46: <D.25556>>
  <D.25543>:
  <D.25544>:
  <D.25545>:
  <D.25546>:
  <D.25547>:
  D.28425 = ji1->data.token;
  D.28426 = D.28425->image;
  D.28427 = ji2->data.token;
  D.28428 = D.28427->image;
  if (D.28426 != D.28428) goto <D.28423>; else goto <D.28429>;
  <D.28429>:
  D.28425 = ji1->data.token;
  D.28430 = D.28425->token;
  D.28427 = ji2->data.token;
  D.28431 = D.28427->token;
  if (D.28430 != D.28431) goto <D.28423>; else goto <D.28432>;
  <D.28432>:
  D.28425 = ji1->data.token;
  D.28433 = D.28425->has_context;
  D.28427 = ji2->data.token;
  D.28434 = D.28427->has_context;
  if (D.28433 != D.28434) goto <D.28423>; else goto <D.28435>;
  <D.28435>:
  D.28425 = ji1->data.token;
  D.28436 = D.28425->context.class_inst;
  D.28427 = ji2->data.token;
  D.28437 = D.28427->context.class_inst;
  if (D.28436 != D.28437) goto <D.28423>; else goto <D.28438>;
  <D.28438>:
  D.28425 = ji1->data.token;
  D.28439 = D.28425->context.method_inst;
  D.28427 = ji2->data.token;
  D.28440 = D.28427->context.method_inst;
  if (D.28439 != D.28440) goto <D.28423>; else goto <D.28424>;
  <D.28423>:
  D.28422 = 0;
  return D.28422;
  <D.28424>:
  goto <D.25548>;
  <D.25549>:
  D.28441 = ji2->data.name;
  D.28442 = ji1->data.name;
  D.28422 = monoeg_g_str_equal (D.28442, D.28441);
  return D.28422;
  <D.25550>:
  {
    struct MonoJumpInfoRgctxEntry * e1;
    struct MonoJumpInfoRgctxEntry * e2;

    e1 = ji1->data.rgctx_entry;
    e2 = ji2->data.rgctx_entry;
    D.28446 = e1->method;
    D.28447 = e2->method;
    if (D.28446 == D.28447) goto <D.28448>; else goto <D.28444>;
    <D.28448>:
    D.28449 = e1->in_mrgctx;
    D.28450 = e2->in_mrgctx;
    if (D.28449 == D.28450) goto <D.28451>; else goto <D.28444>;
    <D.28451>:
    D.28452 = e1->info_type;
    D.28453 = e2->info_type;
    if (D.28452 == D.28453) goto <D.28454>; else goto <D.28444>;
    <D.28454>:
    D.28455 = e2->data;
    D.28456 = e1->data;
    D.28457 = mono_patch_info_equal (D.28456, D.28455);
    if (D.28457 != 0) goto <D.28458>; else goto <D.28444>;
    <D.28458>:
    iftmp.89 = 1;
    goto <D.28445>;
    <D.28444>:
    iftmp.89 = 0;
    <D.28445>:
    D.28422 = iftmp.89;
    return D.28422;
  }
  <D.25553>:
  {
    struct MonoJumpInfoGSharedVtCall * c1;
    struct MonoJumpInfoGSharedVtCall * c2;

    c1 = ji1->data.gsharedvt;
    c2 = ji2->data.gsharedvt;
    D.28462 = c1->sig;
    D.28463 = c2->sig;
    if (D.28462 == D.28463) goto <D.28464>; else goto <D.28460>;
    <D.28464>:
    D.28465 = c1->method;
    D.28466 = c2->method;
    if (D.28465 == D.28466) goto <D.28467>; else goto <D.28460>;
    <D.28467>:
    iftmp.90 = 1;
    goto <D.28461>;
    <D.28460>:
    iftmp.90 = 0;
    <D.28461>:
    D.28422 = iftmp.90;
    return D.28422;
  }
  <D.25556>:
  D.28468 = ji1->data.gsharedvt_method;
  D.28469 = D.28468->method;
  D.28470 = ji2->data.gsharedvt_method;
  D.28471 = D.28470->method;
  D.28472 = D.28469 == D.28471;
  D.28422 = (gint) D.28472;
  return D.28422;
  <D.25557>:
  D.28473 = ji1->data.target;
  D.28474 = ji2->data.target;
  if (D.28473 != D.28474) goto <D.28475>; else goto <D.28476>;
  <D.28475>:
  D.28422 = 0;
  return D.28422;
  <D.28476>:
  goto <D.25548>;
  <D.25548>:
  D.28422 = 1;
  return D.28422;
}


mono_resolve_patch_target (struct MonoMethod * method, struct MonoDomain * domain, guint8 * code, struct MonoJumpInfo * patch_info, gboolean run_cctors)
{
  int D.28478;
  sizetype D.28479;
  <unnamed type> D.28480;
  struct MonoBasicBlock * D.28481;
  int D.28482;
  sizetype D.28483;
  struct MonoInst * D.28484;
  int D.28485;
  sizetype D.28486;
  int D.28487;
  sizetype D.28488;
  const char * D.28489;
  struct MonoMethod * D.28494;
  union mono_mutex_t * D.28498;
  _Bool D.28501;
  long int D.28502;
  long int D.28503;
  void * D.28506;
  struct GHashTable * D.28507;
  struct GHashTable * D.28510;
  _Bool D.28515;
  long int D.28516;
  long int D.28517;
  unsigned char D.28523;
  unsigned char D.28524;
  struct MonoJumpInfoBBTable * D.28526;
  int D.28527;
  unsigned int D.28528;
  unsigned int D.28529;
  int D.28530;
  struct MonoJitDynamicMethodInfo * D.28531;
  struct MonoCodeManager * D.28532;
  int mono_aot_only.91;
  unsigned int i.92;
  unsigned int D.28538;
  void * * D.28539;
  struct MonoBasicBlock * * D.28540;
  struct MonoBasicBlock * * D.28541;
  struct MonoBasicBlock * D.28542;
  sizetype D.28543;
  void * D.28544;
  struct MonoClass * D.28545;
  short unsigned int D.28546;
  int D.28547;
  int D.28548;
  int D.28549;
  _Bool D.28550;
  long int D.28551;
  long int D.28552;
  _Bool D.28555;
  long int D.28556;
  long int D.28557;
  struct MonoClassField * D.28560;
  struct MonoClass * D.28561;
  int D.28562;
  _Bool D.28567;
  long int D.28568;
  long int D.28569;
  struct GHashTable * D.28572;
  _Bool D.28577;
  long int D.28578;
  long int D.28579;
  _Bool D.28582;
  long int D.28583;
  long int D.28584;
  void * D.28587;
  _Bool D.28588;
  long int D.28589;
  long int D.28590;
  unsigned char D.28595;
  unsigned char D.28596;
  struct MonoClass * D.28598;
  unsigned int D.28599;
  unsigned int D.28600;
  int D.28603;
  void * D.28607;
  int D.28608;
  sizetype D.28609;
  struct MonoJumpInfoToken * D.28610;
  unsigned int D.28611;
  unsigned int D.28612;
  struct MonoImage * D.28613;
  unsigned int rva.93;
  unsigned int D.28615;
  struct MonoGenericContext * iftmp.94;
  int D.28617;
  struct MonoClass * handle_class.95;
  struct MonoClass * D.28622;
  struct MonoGenericContext * iftmp.96;
  struct MonoClass * handle_class.97;
  const char * D.28628;
  short unsigned int D.28629;
  int D.28630;
  int D.28631;
  const char * exc_arg.98;
  const char * exc_class.99;
  struct MonoImage * D.28642;
  struct MonoException * D.28643;
  char * D.28644;
  _Bool D.28647;
  _Bool D.28648;
  char * D.28651;
  struct MonoClass * D.28652;
  _Bool D.28653;
  long int D.28654;
  long int D.28655;
  struct MonoGenericContext * D.28658;
  struct MonoGenericInst * D.28659;
  struct MonoJumpInfo * D.28660;
  <unnamed type> D.28661;
  struct MonoMethod * D.28662;
  struct MonoGenericContext * D.28663;
  <unnamed type> D.28664;
  struct MonoClass * D.28665;
  struct MonoType * D.28666;
  int D.28667;
  struct MonoGenericContext * D.28668;
  struct MonoMethod * D.28669;
  struct MonoGenericContext * D.28670;
  struct MonoClassField * D.28671;
  struct MonoGenericContext * D.28672;
  struct MonoMethodSignature * D.28673;
  struct MonoJumpInfoGSharedVtCall * D.28674;
  struct MonoGenericContext * D.28675;
  struct MonoMethod * D.28676;
  struct GPtrArray * D.28677;
  struct GPtrArray * D.28678;
  void * * D.28679;
  unsigned int i.100;
  unsigned int D.28681;
  void * * D.28682;
  struct GPtrArray * D.28683;
  unsigned int i.101;
  unsigned int D.28685;
  struct MonoGenericContext * D.28686;
  int mono_use_llvm.102;
  _Bool D.28691;
  long int D.28692;
  long int D.28693;
  struct MonoJumpInfoImtTramp * D.28696;
  int D.28697;
  struct MonoMethod * D.28698;
  unsigned int mono_jit_tls_id.103;
  const void * D.28700;
  <unnamed type> D.28701;
  unsigned char * ip;
  const void * target;

  D.28478 = patch_info->ip.i;
  D.28479 = (sizetype) D.28478;
  ip = code + D.28479;
  target = 0B;
  D.28480 = patch_info->type;
  switch (D.28480) <default: <D.25665>, case 0: <D.25567>, case 1: <D.25569>, case 2: <D.25570>, case 3: <D.25578>, case 4: <D.25577>, case 5: <D.25572>, case 6: <D.25589>, case 7: <D.25573>, case 8: <D.25583>, case 10: <D.25610>, case 11: <D.25590>, case 12: <D.25591>, case 13: <D.25592>, case 14: <D.25596>, case 15: <D.25597>, case 16: <D.25600>, case 17: <D.25611>, case 18: <D.25615>, case 19: <D.25612>, case 20: <D.25608>, case 21: <D.25609>, case 22: <D.25571>, case 23: <D.25594>, case 24: <D.25595>, case 25: <D.25627>, case 26: <D.25628>, case 27: <D.25629>, case 28: <D.25618>, case 29: <D.25605>, case 30: <D.25599>, case 31: <D.25619>, case 32: <D.25575>, case 33: <D.25624>, case 34: <D.25625>, case 35: <D.25631>, case 36: <D.25652>, case 37: <D.25653>, case 38: <D.25654>, case 40: <D.25655>, case 41: <D.25656>, case 42: <D.25657>, case 43: <D.25660>, case 44: <D.25593>, case 47: <D.25661>, case 48: <D.25662>, case 49: <D.25664>, case 50: <D.25579>, case 51: <D.25630>>
  <D.25567>:
  D.28481 = patch_info->data.bb;
  D.28482 = D.28481->native_offset;
  D.28483 = (sizetype) D.28482;
  target = code + D.28483;
  goto <D.25568>;
  <D.25569>:
  target = patch_info->data.target;
  goto <D.25568>;
  <D.25570>:
  D.28484 = patch_info->data.inst;
  D.28485 = D.28484->data.op[0].const_val;
  D.28486 = (sizetype) D.28485;
  target = code + D.28486;
  goto <D.25568>;
  <D.25571>:
  target = ip;
  goto <D.25568>;
  <D.25572>:
  D.28487 = patch_info->data.offset;
  D.28488 = (sizetype) D.28487;
  target = code + D.28488;
  goto <D.25568>;
  <D.25573>:
  {
    struct MonoJitICallInfo * mi;

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

    D.28489 = patch_info->data.name;
    mi = mono_find_jit_icall_by_name (D.28489);
    if (mi == 0B) goto <D.28492>; else goto <D.28493>;
    <D.28492>:
    D.28489 = patch_info->data.name;
    monoeg_g_log (0B, 16, "unknown MONO_PATCH_INFO_JIT_ICALL_ADDR %s", D.28489);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3308);
    <D.28493>:
    target = mi->func;
    goto <D.25568>;
  }
  <D.25577>:
  D.28494 = patch_info->data.method;
  target = mono_create_jump_trampoline (domain, D.28494, 0);
  goto <D.25568>;
  <D.25578>:
  D.28494 = patch_info->data.method;
  if (D.28494 == method) goto <D.28495>; else goto <D.28496>;
  <D.28495>:
  target = code;
  goto <D.28497>;
  <D.28496>:
  D.28494 = patch_info->data.method;
  target = mono_create_jit_trampoline_in_domain (domain, D.28494);
  <D.28497>:
  goto <D.25568>;
  <D.25579>:
  {
    void * code_slot;

    {
      int ret;

      D.28498 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.28498);
      if (ret != 0) goto <D.28499>; else goto <D.28500>;
      <D.28499>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.28500>:
      D.28501 = ret != 0;
      D.28502 = (long int) D.28501;
      D.28503 = __builtin_expect (D.28502, 0);
      if (D.28503 != 0) goto <D.28504>; else goto <D.28505>;
      <D.28504>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3343, "ret == 0");
      <D.28505>:
    }
    D.28506 = domain->runtime_info;
    D.28507 = MEM[(struct MonoJitDomainInfo *)D.28506].method_code_hash;
    if (D.28507 == 0B) goto <D.28508>; else goto <D.28509>;
    <D.28508>:
    D.28506 = domain->runtime_info;
    D.28510 = monoeg_g_hash_table_new (0B, 0B);
    MEM[(struct MonoJitDomainInfo *)D.28506].method_code_hash = D.28510;
    <D.28509>:
    D.28494 = patch_info->data.method;
    D.28506 = domain->runtime_info;
    D.28507 = MEM[(struct MonoJitDomainInfo *)D.28506].method_code_hash;
    code_slot = monoeg_g_hash_table_lookup (D.28507, D.28494);
    if (code_slot == 0B) goto <D.28511>; else goto <D.28512>;
    <D.28511>:
    code_slot = mono_domain_alloc0 (domain, 4);
    D.28494 = patch_info->data.method;
    D.28506 = domain->runtime_info;
    D.28507 = MEM[(struct MonoJitDomainInfo *)D.28506].method_code_hash;
    monoeg_g_hash_table_insert_replace (D.28507, D.28494, code_slot, 0);
    <D.28512>:
    {
      int ret;

      D.28498 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.28498);
      if (ret != 0) goto <D.28513>; else goto <D.28514>;
      <D.28513>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.28514>:
      D.28515 = ret != 0;
      D.28516 = (long int) D.28515;
      D.28517 = __builtin_expect (D.28516, 0);
      if (D.28517 != 0) goto <D.28518>; else goto <D.28519>;
      <D.28518>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3351, "ret == 0");
      <D.28519>:
    }
    target = code_slot;
    goto <D.25568>;
  }
  <D.25583>:
  {
    void * * jump_table;
    int i;

    if (method != 0B) goto <D.28522>; else goto <D.28520>;
    <D.28522>:
    D.28523 = BIT_FIELD_REF <*method, 8, 168>;
    D.28524 = D.28523 & 2;
    if (D.28524 != 0) goto <D.28525>; else goto <D.28520>;
    <D.28525>:
    D.28526 = patch_info->data.table;
    D.28527 = D.28526->table_size;
    D.28528 = (unsigned int) D.28527;
    D.28529 = D.28528 * 4;
    D.28530 = (int) D.28529;
    D.28531 = mono_dynamic_code_hash_lookup (domain, method);
    D.28532 = D.28531->code_mp;
    jump_table = mono_code_manager_reserve (D.28532, D.28530);
    goto <D.28521>;
    <D.28520>:
    mono_aot_only.91 = mono_aot_only;
    if (mono_aot_only.91 != 0) goto <D.28534>; else goto <D.28535>;
    <D.28534>:
    D.28526 = patch_info->data.table;
    D.28527 = D.28526->table_size;
    D.28528 = (unsigned int) D.28527;
    D.28529 = D.28528 * 4;
    jump_table = mono_domain_alloc (domain, D.28529);
    goto <D.28536>;
    <D.28535>:
    D.28526 = patch_info->data.table;
    D.28527 = D.28526->table_size;
    D.28528 = (unsigned int) D.28527;
    D.28529 = D.28528 * 4;
    D.28530 = (int) D.28529;
    jump_table = mono_domain_code_reserve (domain, D.28530);
    <D.28536>:
    <D.28521>:
    i = 0;
    goto <D.25587>;
    <D.25586>:
    i.92 = (unsigned int) i;
    D.28538 = i.92 * 4;
    D.28539 = jump_table + D.28538;
    D.28526 = patch_info->data.table;
    D.28540 = D.28526->table;
    i.92 = (unsigned int) i;
    D.28538 = i.92 * 4;
    D.28541 = D.28540 + D.28538;
    D.28542 = *D.28541;
    D.28543 = (sizetype) D.28542;
    D.28544 = code + D.28543;
    *D.28539 = D.28544;
    i = i + 1;
    <D.25587>:
    D.28526 = patch_info->data.table;
    D.28527 = D.28526->table_size;
    if (D.28527 > i) goto <D.25586>; else goto <D.25588>;
    <D.25588>:
    target = jump_table;
    goto <D.25568>;
  }
  <D.25589>:
  <D.25590>:
  <D.25591>:
  <D.25592>:
  <D.25593>:
  target = patch_info->data.target;
  goto <D.25568>;
  <D.25594>:
  D.28545 = patch_info->data.klass;
  mono_class_init (D.28545);
  D.28545 = patch_info->data.klass;
  D.28546 = D.28545->interface_id;
  D.28547 = (int) D.28546;
  target = (const void *) D.28547;
  goto <D.25568>;
  <D.25595>:
  D.28545 = patch_info->data.klass;
  mono_class_init (D.28545);
  D.28545 = patch_info->data.klass;
  D.28546 = D.28545->interface_id;
  D.28547 = (int) D.28546;
  D.28548 = ~D.28547;
  D.28549 = D.28548 * 4;
  target = (const void *) D.28549;
  goto <D.25568>;
  <D.25596>:
  D.28545 = patch_info->data.klass;
  target = mono_class_vtable (domain, D.28545);
  D.28550 = target == 0B;
  D.28551 = (long int) D.28550;
  D.28552 = __builtin_expect (D.28551, 0);
  if (D.28552 != 0) goto <D.28553>; else goto <D.28554>;
  <D.28553>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3412, "target");
  <D.28554>:
  goto <D.25568>;
  <D.25597>:
  {
    struct MonoVTable * vtable;

    D.28545 = patch_info->data.klass;
    vtable = mono_class_vtable (domain, D.28545);
    D.28555 = vtable == 0B;
    D.28556 = (long int) D.28555;
    D.28557 = __builtin_expect (D.28556, 0);
    if (D.28557 != 0) goto <D.28558>; else goto <D.28559>;
    <D.28558>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3417, "vtable");
    <D.28559>:
    target = mono_create_class_init_trampoline (vtable);
    goto <D.25568>;
  }
  <D.25599>:
  D.28545 = patch_info->data.klass;
  target = mono_create_delegate_trampoline (domain, D.28545);
  goto <D.25568>;
  <D.25600>:
  {
    struct MonoVTable * vtable;

    D.28560 = patch_info->data.field;
    D.28561 = D.28560->parent;
    vtable = mono_class_vtable (domain, D.28561);
    D.28560 = patch_info->data.field;
    D.28562 = mono_class_field_is_special_static (D.28560);
    if (D.28562 != 0) goto <D.28563>; else goto <D.28564>;
    <D.28563>:
    {
      void * addr;

      addr = 0B;
      {
        int ret;

        D.28498 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.28498);
        if (ret != 0) goto <D.28565>; else goto <D.28566>;
        <D.28565>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28566>:
        D.28567 = ret != 0;
        D.28568 = (long int) D.28567;
        D.28569 = __builtin_expect (D.28568, 0);
        if (D.28569 != 0) goto <D.28570>; else goto <D.28571>;
        <D.28570>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3430, "ret == 0");
        <D.28571>:
      }
      D.28572 = domain->special_static_fields;
      if (D.28572 != 0B) goto <D.28573>; else goto <D.28574>;
      <D.28573>:
      D.28560 = patch_info->data.field;
      D.28572 = domain->special_static_fields;
      addr = monoeg_g_hash_table_lookup (D.28572, D.28560);
      <D.28574>:
      {
        int ret;

        D.28498 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.28498);
        if (ret != 0) goto <D.28575>; else goto <D.28576>;
        <D.28575>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28576>:
        D.28577 = ret != 0;
        D.28578 = (long int) D.28577;
        D.28579 = __builtin_expect (D.28578, 0);
        if (D.28579 != 0) goto <D.28580>; else goto <D.28581>;
        <D.28580>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3433, "ret == 0");
        <D.28581>:
      }
      D.28582 = addr == 0B;
      D.28583 = (long int) D.28582;
      D.28584 = __builtin_expect (D.28583, 0);
      if (D.28584 != 0) goto <D.28585>; else goto <D.28586>;
      <D.28585>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3434, "addr");
      <D.28586>:
      D.28587 = addr;
      return D.28587;
    }
    <D.28564>:
    D.28588 = vtable == 0B;
    D.28589 = (long int) D.28588;
    D.28590 = __builtin_expect (D.28589, 0);
    if (D.28590 != 0) goto <D.28591>; else goto <D.28592>;
    <D.28591>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3438, "vtable");
    <D.28592>:
    D.28595 = BIT_FIELD_REF <*vtable, 8, 184>;
    D.28596 = D.28595 & 2;
    if (D.28596 == 0) goto <D.28597>; else goto <D.28593>;
    <D.28597>:
    D.28598 = vtable->klass;
    D.28599 = D.28598->flags;
    D.28600 = D.28599 & 1048576;
    if (D.28600 == 0) goto <D.28601>; else goto <D.28593>;
    <D.28601>:
    if (method != 0B) goto <D.28602>; else goto <D.28593>;
    <D.28602>:
    D.28598 = vtable->klass;
    D.28603 = mono_class_needs_cctor_run (D.28598, method);
    if (D.28603 != 0) goto <D.28604>; else goto <D.28593>;
    <D.28604>:
    goto <D.28594>;
    <D.28593>:
    if (run_cctors != 0) goto <D.28605>; else goto <D.28606>;
    <D.28605>:
    mono_runtime_class_init (vtable);
    <D.28606>:
    <D.28594>:
    D.28607 = mono_vtable_get_static_field_data (vtable);
    D.28560 = patch_info->data.field;
    D.28608 = D.28560->offset;
    D.28609 = (sizetype) D.28608;
    target = D.28607 + D.28609;
    goto <D.25568>;
  }
  <D.25605>:
  {
    guint32 field_index;
    guint32 rva;

    try
      {
        D.28610 = patch_info->data.token;
        D.28611 = D.28610->token;
        field_index = D.28611 & 16777215;
        D.28612 = field_index + 4294967295;
        D.28610 = patch_info->data.token;
        D.28613 = D.28610->image;
        mono_metadata_field_info (D.28613, D.28612, 0B, &rva, 0B);
        rva.93 = rva;
        D.28610 = patch_info->data.token;
        D.28613 = D.28610->image;
        target = mono_image_rva_map (D.28613, rva.93);
        goto <D.25568>;
      }
    finally
      {
        rva = {CLOBBER};
      }
  }
  <D.25608>:
  <D.25609>:
  target = patch_info->data.target;
  goto <D.25568>;
  <D.25610>:
  target = patch_info->data.name;
  goto <D.25568>;
  <D.25611>:
  D.28610 = patch_info->data.token;
  D.28611 = D.28610->token;
  D.28615 = D.28611 & 16777215;
  D.28610 = patch_info->data.token;
  D.28613 = D.28610->image;
  target = mono_ldstr (domain, D.28613, D.28615);
  goto <D.25568>;
  <D.25612>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.28610 = patch_info->data.token;
        D.28617 = D.28610->has_context;
        if (D.28617 != 0) goto <D.28618>; else goto <D.28619>;
        <D.28618>:
        D.28610 = patch_info->data.token;
        iftmp.94 = &D.28610->context;
        goto <D.28620>;
        <D.28619>:
        iftmp.94 = 0B;
        <D.28620>:
        D.28610 = patch_info->data.token;
        D.28611 = D.28610->token;
        D.28610 = patch_info->data.token;
        D.28613 = D.28610->image;
        handle = mono_ldtoken (D.28613, D.28611, &handle_class, iftmp.94);
        handle_class.95 = handle_class;
        mono_class_init (handle_class.95);
        D.28622 = mono_class_from_mono_type (handle);
        mono_class_init (D.28622);
        target = mono_type_get_object (domain, handle);
        goto <D.25568>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.25615>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.28610 = patch_info->data.token;
        D.28617 = D.28610->has_context;
        if (D.28617 != 0) goto <D.28624>; else goto <D.28625>;
        <D.28624>:
        D.28610 = patch_info->data.token;
        iftmp.96 = &D.28610->context;
        goto <D.28626>;
        <D.28625>:
        iftmp.96 = 0B;
        <D.28626>:
        D.28610 = patch_info->data.token;
        D.28611 = D.28610->token;
        D.28610 = patch_info->data.token;
        D.28613 = D.28610->image;
        handle = mono_ldtoken (D.28613, D.28611, &handle_class, iftmp.96);
        handle_class.97 = handle_class;
        mono_class_init (handle_class.97);
        target = handle;
        goto <D.25568>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.25618>:
  D.28610 = patch_info->data.token;
  D.28611 = D.28610->token;
  D.28610 = patch_info->data.token;
  D.28613 = D.28610->image;
  D.28628 = mono_metadata_blob_heap (D.28613, D.28611);
  target = D.28628 + 2;
  goto <D.25568>;
  <D.25619>:
  D.28494 = patch_info->data.method;
  D.28629 = D.28494->flags;
  D.28630 = (int) D.28629;
  D.28631 = D.28630 & 8192;
  if (D.28631 != 0) goto <D.28632>; else goto <D.28633>;
  <D.28632>:
  {
    const char * exc_class;
    const char * exc_arg;

    try
      {
        if (run_cctors != 0) goto <D.28634>; else goto <D.28635>;
        <D.28634>:
        D.28494 = patch_info->data.method;
        target = mono_lookup_pinvoke_call (D.28494, &exc_class, &exc_arg);
        if (target == 0B) goto <D.28636>; else goto <D.28637>;
        <D.28636>:
        mono_aot_only.91 = mono_aot_only;
        if (mono_aot_only.91 != 0) goto <D.28638>; else goto <D.28639>;
        <D.28638>:
        exc_arg.98 = exc_arg;
        exc_class.99 = exc_class;
        D.28642 = mono_defaults.corlib;
        D.28643 = mono_exception_from_name_msg (D.28642, "System", exc_class.99, exc_arg.98);
        mono_raise_exception (D.28643);
        <D.28639>:
        D.28494 = patch_info->data.method;
        D.28644 = mono_method_full_name (D.28494, 1);
        monoeg_g_log (0B, 4, "Unable to resolve pinvoke method \'%s\' Re-run with MONO_LOG_LEVEL=debug for more information.\n", D.28644);
        <D.25622>:
        goto <D.25622>;
        <D.28637>:
        goto <D.28645>;
        <D.28635>:
        target = 0B;
        <D.28645>:
      }
    finally
      {
        exc_class = {CLOBBER};
        exc_arg = {CLOBBER};
      }
  }
  goto <D.28646>;
  <D.28633>:
  D.28494 = patch_info->data.method;
  target = mono_lookup_internal_call (D.28494);
  D.28550 = target == 0B;
  D.28647 = run_cctors != 0;
  D.28648 = D.28550 & D.28647;
  if (D.28648 != 0) goto <D.28649>; else goto <D.28650>;
  <D.28649>:
  D.28494 = patch_info->data.method;
  D.28651 = mono_method_full_name (D.28494, 1);
  monoeg_g_log (0B, 4, "Unregistered icall \'%s\'\n", D.28651);
  <D.25623>:
  goto <D.25623>;
  <D.28650>:
  <D.28646>:
  goto <D.25568>;
  <D.25624>:
  target = mono_thread_interruption_request_flag ();
  goto <D.25568>;
  <D.25625>:
  {
    struct MonoVTable * vtable;

    D.28494 = patch_info->data.method;
    D.28652 = D.28494->klass;
    vtable = mono_class_vtable (domain, D.28652);
    D.28653 = vtable == 0B;
    D.28654 = (long int) D.28653;
    D.28655 = __builtin_expect (D.28654, 0);
    if (D.28655 != 0) goto <D.28656>; else goto <D.28657>;
    <D.28656>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3524, "vtable");
    <D.28657>:
    D.28494 = patch_info->data.method;
    D.28658 = mini_method_get_context (D.28494);
    D.28659 = D.28658->method_inst;
    target = mono_method_lookup_rgctx (vtable, D.28659);
    goto <D.25568>;
  }
  <D.25627>:
  <D.25628>:
  <D.25629>:
  <D.25630>:
  goto <D.25568>;
  <D.25631>:
  {
    struct MonoJumpInfoRgctxEntry * entry;
    guint32 slot;

    entry = patch_info->data.rgctx_entry;
    slot = 4294967295;
    D.28660 = entry->data;
    D.28661 = D.28660->type;
    switch (D.28661) <default: <D.25651>, case 3: <D.25636>, case 6: <D.25637>, case 11: <D.25634>, case 13: <D.25638>, case 44: <D.25639>, case 45: <D.25640>, case 46: <D.25642>>
    <D.25634>:
    D.28662 = entry->method;
    D.28663 = mono_method_get_context (D.28662);
    D.28664 = entry->info_type;
    D.28660 = entry->data;
    D.28665 = D.28660->data.klass;
    D.28666 = &D.28665->byval_arg;
    D.28667 = entry->in_mrgctx;
    D.28662 = entry->method;
    slot = mono_method_lookup_or_register_info (D.28662, D.28667, D.28666, D.28664, D.28663);
    goto <D.25635>;
    <D.25636>:
    <D.25637>:
    D.28662 = entry->method;
    D.28668 = mono_method_get_context (D.28662);
    D.28664 = entry->info_type;
    D.28660 = entry->data;
    D.28669 = D.28660->data.method;
    D.28667 = entry->in_mrgctx;
    D.28662 = entry->method;
    slot = mono_method_lookup_or_register_info (D.28662, D.28667, D.28669, D.28664, D.28668);
    goto <D.25635>;
    <D.25638>:
    D.28662 = entry->method;
    D.28670 = mono_method_get_context (D.28662);
    D.28664 = entry->info_type;
    D.28660 = entry->data;
    D.28671 = D.28660->data.field;
    D.28667 = entry->in_mrgctx;
    D.28662 = entry->method;
    slot = mono_method_lookup_or_register_info (D.28662, D.28667, D.28671, D.28664, D.28670);
    goto <D.25635>;
    <D.25639>:
    D.28662 = entry->method;
    D.28672 = mono_method_get_context (D.28662);
    D.28664 = entry->info_type;
    D.28660 = entry->data;
    D.28673 = D.28660->data.sig;
    D.28667 = entry->in_mrgctx;
    D.28662 = entry->method;
    slot = mono_method_lookup_or_register_info (D.28662, D.28667, D.28673, D.28664, D.28672);
    goto <D.25635>;
    <D.25640>:
    {
      struct MonoJumpInfoGSharedVtCall * call_info;

      call_info = monoeg_malloc0 (8);
      D.28660 = entry->data;
      D.28674 = D.28660->data.gsharedvt;
      memcpy (call_info, D.28674, 8);
      D.28662 = entry->method;
      D.28675 = mono_method_get_context (D.28662);
      D.28664 = entry->info_type;
      D.28667 = entry->in_mrgctx;
      D.28662 = entry->method;
      slot = mono_method_lookup_or_register_info (D.28662, D.28667, call_info, D.28664, D.28675);
      goto <D.25635>;
    }
    <D.25642>:
    {
      struct MonoGSharedVtMethodInfo * info;
      struct MonoGSharedVtMethodInfo * oinfo;
      int i;

      D.28660 = entry->data;
      oinfo = D.28660->data.gsharedvt_method;
      info = monoeg_malloc0 (8);
      D.28676 = oinfo->method;
      info->method = D.28676;
      D.28677 = monoeg_g_ptr_array_new ();
      info->entries = D.28677;
      i = 0;
      goto <D.25649>;
      <D.25648>:
      {
        struct MonoRuntimeGenericContextInfoTemplate * otemplate;
        struct MonoRuntimeGenericContextInfoTemplate * template;

        D.28678 = oinfo->entries;
        D.28679 = D.28678->pdata;
        i.100 = (unsigned int) i;
        D.28681 = i.100 * 4;
        D.28682 = D.28679 + D.28681;
        otemplate = *D.28682;
        template = monoeg_malloc0 (12);
        memcpy (template, otemplate, 12);
        D.28683 = info->entries;
        monoeg_g_ptr_array_add (D.28683, template);
      }
      i = i + 1;
      <D.25649>:
      i.101 = (unsigned int) i;
      D.28678 = oinfo->entries;
      D.28685 = D.28678->len;
      if (i.101 < D.28685) goto <D.25648>; else goto <D.25650>;
      <D.25650>:
      D.28662 = entry->method;
      D.28686 = mono_method_get_context (D.28662);
      D.28664 = entry->info_type;
      D.28667 = entry->in_mrgctx;
      D.28662 = entry->method;
      slot = mono_method_lookup_or_register_info (D.28662, D.28667, info, D.28664, D.28686);
      goto <D.25635>;
    }
    <D.25651>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3579);
    <D.25635>:
    target = mono_create_rgctx_lazy_fetch_trampoline (slot);
    goto <D.25568>;
  }
  <D.25652>:
  target = mono_create_generic_class_init_trampoline ();
  goto <D.25568>;
  <D.25653>:
  target = mono_create_monitor_enter_trampoline ();
  goto <D.25568>;
  <D.25654>:
  target = mono_create_monitor_exit_trampoline ();
  goto <D.25568>;
  <D.25655>:
  if (run_cctors == 0) goto <D.28687>; else goto <D.28688>;
  <D.28687>:
  target = 0B;
  goto <D.28689>;
  <D.28688>:
  target = mono_arch_get_seq_point_info (domain, code);
  <D.28689>:
  goto <D.25568>;
  <D.25656>:
  mono_use_llvm.102 = mono_use_llvm;
  D.28691 = mono_use_llvm.102 == 0;
  D.28692 = (long int) D.28691;
  D.28693 = __builtin_expect (D.28692, 0);
  if (D.28693 != 0) goto <D.28694>; else goto <D.28695>;
  <D.28694>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3606, "mono_use_llvm");
  <D.28695>:
  D.28696 = patch_info->data.imt_tramp;
  D.28697 = D.28696->vt_offset;
  D.28696 = patch_info->data.imt_tramp;
  D.28698 = D.28696->method;
  target = mono_create_llvm_imt_trampoline (domain, D.28698, D.28697);
  goto <D.25568>;
  <D.25657>:
  {
    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.25568>;
      }
    finally
      {
        card_table_shift_bits = {CLOBBER};
        card_table_mask = {CLOBBER};
      }
  }
  <D.25660>:
  target = mono_domain_alloc0 (domain, 4);
  goto <D.25568>;
  <D.25661>:
  mono_jit_tls_id.103 = mono_jit_tls_id;
  target = (const void *) mono_jit_tls_id.103;
  goto <D.25568>;
  <D.25662>:
  {
    int offset;

    D.28700 = patch_info->data.target;
    D.28701 = (<unnamed type>) D.28700;
    offset = mini_get_tls_offset (D.28701);
    offset = mono_arch_translate_tls_offset (offset);
    target = (const void *) offset;
    goto <D.25568>;
  }
  <D.25664>:
  target = 0B;
  goto <D.25568>;
  <D.25665>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3642);
  <D.25568>:
  D.28587 = target;
  return D.28587;
}


mono_dynamic_code_hash_lookup (struct MonoDomain * domain, struct MonoMethod * method)
{
  void * D.28708;
  struct GHashTable * D.28709;
  struct MonoJitDynamicMethodInfo * D.28713;
  struct MonoJitDynamicMethodInfo * res;

  D.28708 = domain->runtime_info;
  D.28709 = MEM[(struct MonoJitDomainInfo *)D.28708].dynamic_code_hash;
  if (D.28709 != 0B) goto <D.28710>; else goto <D.28711>;
  <D.28710>:
  D.28708 = domain->runtime_info;
  D.28709 = MEM[(struct MonoJitDomainInfo *)D.28708].dynamic_code_hash;
  res = monoeg_g_hash_table_lookup (D.28709, method);
  goto <D.28712>;
  <D.28711>:
  res = 0B;
  <D.28712>:
  D.28713 = res;
  return D.28713;
}


mono_add_seq_point (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, int native_offset)
{
  struct GPtrArray * D.28715;
  struct GSList * D.28718;
  struct MonoMemPool * D.28719;
  struct GSList * D.28720;

  ins->data.op[0].const_val = native_offset;
  D.28715 = cfg->seq_points;
  monoeg_g_ptr_array_add (D.28715, ins);
  if (bb != 0B) goto <D.28716>; else goto <D.28717>;
  <D.28716>:
  D.28718 = bb->seq_points;
  D.28719 = cfg->mempool;
  D.28720 = g_slist_prepend_mempool (D.28719, D.28718, ins);
  bb->seq_points = D.28720;
  bb->last_seq_point = ins;
  <D.28717>:
}


mono_add_var_location (struct MonoCompile * cfg, struct MonoInst * var, gboolean is_reg, int reg, int offset, int from, int to)
{
  struct MonoMemPool * D.28721;
  _Bool D.28724;
  long int D.28725;
  long int D.28726;
  struct MonoInst * * D.28729;
  struct MonoInst * D.28730;
  struct GSList * D.28733;
  struct GSList * D.28734;
  struct MonoInst * D.28736;
  struct GSList * D.28739;
  struct GSList * D.28740;
  struct MonoDwarfLocListEntry * entry;

  D.28721 = cfg->mempool;
  entry = mono_mempool_alloc0 (D.28721, 20);
  if (is_reg != 0) goto <D.28722>; else goto <D.28723>;
  <D.28722>:
  D.28724 = offset != 0;
  D.28725 = (long int) D.28724;
  D.28726 = __builtin_expect (D.28725, 0);
  if (D.28726 != 0) goto <D.28727>; else goto <D.28728>;
  <D.28727>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3665, "offset == 0");
  <D.28728>:
  <D.28723>:
  entry->is_reg = is_reg;
  entry->reg = reg;
  entry->offset = offset;
  entry->from = from;
  entry->to = to;
  D.28729 = cfg->args;
  D.28730 = *D.28729;
  if (D.28730 == var) goto <D.28731>; else goto <D.28732>;
  <D.28731>:
  D.28733 = cfg->this_loclist;
  D.28721 = cfg->mempool;
  D.28734 = g_slist_append_mempool (D.28721, D.28733, entry);
  cfg->this_loclist = D.28734;
  goto <D.28735>;
  <D.28732>:
  D.28736 = cfg->rgctx_var;
  if (D.28736 == var) goto <D.28737>; else goto <D.28738>;
  <D.28737>:
  D.28739 = cfg->rgctx_loclist;
  D.28721 = cfg->mempool;
  D.28740 = g_slist_append_mempool (D.28721, D.28739, entry);
  cfg->rgctx_loclist = D.28740;
  <D.28738>:
  <D.28735>:
}


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

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


mono_codegen (struct MonoCompile * cfg)
{
  int mono_using_xdebug.104;
  unsigned int D.28745;
  unsigned int D.28746;
  unsigned char D.28749;
  unsigned char D.28750;
  unsigned int D.28755;
  unsigned int D.28756;
  unsigned int D.28759;
  int D.28760;
  struct MonoMethod * D.28761;
  struct MonoProfileCoverageInfo * D.28762;
  unsigned int D.28763;
  int code.105;
  unsigned char * D.28767;
  int D.28768;
  int D.28769;
  unsigned int D.28770;
  unsigned int D.28771;
  int D.28772;
  int D.28773;
  unsigned int D.28774;
  unsigned int D.28775;
  int D.28776;
  struct MonoBasicBlock * D.28777;
  unsigned int D.28782;
  _Bool D.28783;
  long int D.28784;
  long int D.28785;
  unsigned int max_epilog_size.106;
  unsigned int D.28789;
  unsigned char D.28790;
  unsigned char D.28791;
  void * D.28794;
  struct MonoJitDynamicMethodInfo * D.28795;
  struct MonoCodeManager * D.28796;
  struct MonoDomain * D.28797;
  union mono_mutex_t * D.28798;
  _Bool D.28801;
  long int D.28802;
  long int D.28803;
  _Bool D.28808;
  long int D.28809;
  long int D.28810;
  unsigned int D.28815;
  int D.28816;
  struct MonoCodeManager * D.28818;
  unsigned int D.28820;
  int D.28821;
  _Bool D.28822;
  long int D.28823;
  long int D.28824;
  unsigned int D.28827;
  char * D.28830;
  unsigned char * D.28831;
  unsigned char D.28834;
  struct MonoGenericContainer * D.28836;
  struct MonoClass * D.28838;
  struct MonoGenericContainer * D.28839;
  struct MonoGenericClass * D.28841;
  struct MonoGenericSharingContext * D.28842;
  _Bool D.28845;
  long int D.28846;
  long int D.28847;
  <unnamed-unsigned:1> D.28850;
  int D.28851;
  struct MonoCodeManager * iftmp.107;
  struct MonoJumpInfo * D.28856;
  int D.28861;
  int D.28864;
  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.28742>; else goto <D.28743>;
  <D.28742>:
  code_domain = mono_get_root_domain ();
  goto <D.28744>;
  <D.28743>:
  code_domain = cfg->domain;
  <D.28744>:
  bb = cfg->bb_entry;
  goto <D.25801>;
  <D.25800>:
  cfg->spill_count = 0;
  mono_arch_lowering_pass (cfg, bb);
  D.28745 = cfg->opt;
  D.28746 = D.28745 & 1;
  if (D.28746 != 0) goto <D.28747>; else goto <D.28748>;
  <D.28747>:
  mono_arch_peephole_pass_1 (cfg, bb);
  <D.28748>:
  D.28749 = BIT_FIELD_REF <*cfg, 8, 3400>;
  D.28750 = D.28749 & 16;
  if (D.28750 == 0) goto <D.28751>; else goto <D.28752>;
  <D.28751>:
  mono_local_regalloc (cfg, bb);
  <D.28752>:
  D.28745 = cfg->opt;
  D.28746 = D.28745 & 1;
  if (D.28746 != 0) goto <D.28753>; else goto <D.28754>;
  <D.28753>:
  mono_arch_peephole_pass_2 (cfg, bb);
  <D.28754>:
  bb = bb->next_bb;
  <D.25801>:
  if (bb != 0B) goto <D.25800>; else goto <D.25802>;
  <D.25802>:
  D.28755 = cfg->prof_options;
  D.28756 = D.28755 & 8192;
  if (D.28756 != 0) goto <D.28757>; else goto <D.28758>;
  <D.28757>:
  D.28759 = cfg->num_bblocks;
  D.28760 = (int) D.28759;
  D.28761 = cfg->method;
  D.28762 = mono_profiler_coverage_alloc (D.28761, D.28760);
  cfg->coverage_info = D.28762;
  <D.28758>:
  code = mono_arch_emit_prolog (cfg);
  D.28755 = cfg->prof_options;
  D.28763 = D.28755 & 4096;
  if (D.28763 != 0) goto <D.28764>; else goto <D.28765>;
  <D.28764>:
  code = mono_arch_instrument_prolog (cfg, mono_profiler_method_enter, code, 0);
  <D.28765>:
  code.105 = (int) code;
  D.28767 = cfg->native_code;
  D.28768 = (int) D.28767;
  D.28769 = code.105 - D.28768;
  D.28770 = (unsigned int) D.28769;
  cfg->code_len = D.28770;
  D.28771 = cfg->code_len;
  cfg->prolog_end = D.28771;
  mono_debug_open_method (cfg);
  bb = cfg->bb_entry;
  goto <D.25804>;
  <D.25803>:
  D.28771 = cfg->code_len;
  D.28772 = (int) D.28771;
  bb->native_offset = D.28772;
  D.28771 = cfg->code_len;
  D.28772 = (int) D.28771;
  bb->real_native_offset = D.28772;
  mono_arch_output_basic_block (cfg, bb);
  D.28771 = cfg->code_len;
  D.28773 = bb->native_offset;
  D.28774 = (unsigned int) D.28773;
  D.28775 = D.28771 - D.28774;
  D.28776 = (int) D.28775;
  bb->native_length = D.28776;
  D.28777 = cfg->bb_exit;
  if (D.28777 == bb) goto <D.28778>; else goto <D.28779>;
  <D.28778>:
  D.28771 = cfg->code_len;
  cfg->epilog_begin = D.28771;
  D.28755 = cfg->prof_options;
  D.28763 = D.28755 & 4096;
  if (D.28763 != 0) goto <D.28780>; else goto <D.28781>;
  <D.28780>:
  D.28767 = cfg->native_code;
  D.28771 = cfg->code_len;
  code = D.28767 + D.28771;
  code = mono_arch_instrument_epilog (cfg, mono_profiler_method_leave, code, 0);
  code.105 = (int) code;
  D.28767 = cfg->native_code;
  D.28768 = (int) D.28767;
  D.28769 = code.105 - D.28768;
  D.28770 = (unsigned int) D.28769;
  cfg->code_len = D.28770;
  D.28771 = cfg->code_len;
  D.28782 = cfg->code_size;
  D.28783 = D.28771 >= D.28782;
  D.28784 = (long int) D.28783;
  D.28785 = __builtin_expect (D.28784, 0);
  if (D.28785 != 0) goto <D.28786>; else goto <D.28787>;
  <D.28786>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4077, "cfg->code_len < cfg->code_size");
  <D.28787>:
  <D.28781>:
  mono_arch_emit_epilog (cfg);
  <D.28779>:
  bb = bb->next_bb;
  <D.25804>:
  if (bb != 0B) goto <D.25803>; else goto <D.25805>;
  <D.25805>:
  mono_arch_emit_exceptions (cfg);
  max_epilog_size = 0;
  D.28771 = cfg->code_len;
  max_epilog_size.106 = (unsigned int) max_epilog_size;
  D.28789 = D.28771 + max_epilog_size.106;
  cfg->code_size = D.28789;
  D.28761 = cfg->method;
  D.28790 = BIT_FIELD_REF <*D.28761, 8, 168>;
  D.28791 = D.28790 & 2;
  if (D.28791 != 0) goto <D.28792>; else goto <D.28793>;
  <D.28792>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.28794 = monoeg_malloc0 (8);
    cfg->dynamic_info = D.28794;
    D.28795 = cfg->dynamic_info;
    D.28796 = mono_code_manager_new_dynamic ();
    D.28795->code_mp = D.28796;
    {
      int ret;

      D.28797 = cfg->domain;
      D.28798 = &D.28797->lock.mutex;
      ret = pthread_mutex_lock (D.28798);
      if (ret != 0) goto <D.28799>; else goto <D.28800>;
      <D.28799>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.28800>:
      D.28801 = ret != 0;
      D.28802 = (long int) D.28801;
      D.28803 = __builtin_expect (D.28802, 0);
      if (D.28803 != 0) goto <D.28804>; else goto <D.28805>;
      <D.28804>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4106, "ret == 0");
      <D.28805>:
    }
    D.28795 = cfg->dynamic_info;
    D.28761 = cfg->method;
    D.28797 = cfg->domain;
    mono_dynamic_code_hash_insert (D.28797, D.28761, D.28795);
    {
      int ret;

      D.28797 = cfg->domain;
      D.28798 = &D.28797->lock.mutex;
      ret = pthread_mutex_unlock (D.28798);
      if (ret != 0) goto <D.28806>; else goto <D.28807>;
      <D.28806>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.28807>:
      D.28808 = ret != 0;
      D.28809 = (long int) D.28808;
      D.28810 = __builtin_expect (D.28809, 0);
      if (D.28810 != 0) goto <D.28811>; else goto <D.28812>;
      <D.28811>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4108, "ret == 0");
      <D.28812>:
    }
    mono_using_xdebug.104 = mono_using_xdebug;
    if (mono_using_xdebug.104 != 0) goto <D.28813>; else goto <D.28814>;
    <D.28813>:
    D.28782 = cfg->code_size;
    D.28815 = D.28782 + unwindlen;
    D.28816 = (int) D.28815;
    code = mono_domain_code_reserve (code_domain, D.28816);
    goto <D.28817>;
    <D.28814>:
    D.28782 = cfg->code_size;
    D.28815 = D.28782 + unwindlen;
    D.28816 = (int) D.28815;
    D.28795 = cfg->dynamic_info;
    D.28818 = D.28795->code_mp;
    code = mono_code_manager_reserve (D.28818, D.28816);
    <D.28817>:
  }
  goto <D.28819>;
  <D.28793>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.28782 = cfg->code_size;
    D.28820 = D.28782 + unwindlen;
    D.28821 = (int) D.28820;
    code = mono_domain_code_reserve (code_domain, D.28821);
  }
  <D.28819>:
  D.28822 = code == 0B;
  D.28823 = (long int) D.28822;
  D.28824 = __builtin_expect (D.28823, 0);
  if (D.28824 != 0) goto <D.28825>; else goto <D.28826>;
  <D.28825>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4126, "code");
  <D.28826>:
  D.28771 = cfg->code_len;
  D.28767 = cfg->native_code;
  memcpy (code, D.28767, D.28771);
  D.28767 = cfg->native_code;
  monoeg_g_free (D.28767);
  cfg->native_code = code;
  D.28767 = cfg->native_code;
  D.28771 = cfg->code_len;
  code = D.28767 + D.28771;
  mono_postprocess_patches (cfg);
  D.28827 = cfg->verbose_level;
  if (D.28827 != 0) goto <D.28828>; else goto <D.28829>;
  <D.28828>:
  {
    char * nm;

    D.28761 = cfg->method;
    nm = mono_method_full_name (D.28761, 1);
    D.28797 = cfg->domain;
    D.28830 = D.28797->friendly_name;
    D.28771 = cfg->code_len;
    D.28767 = cfg->native_code;
    D.28771 = cfg->code_len;
    D.28831 = D.28767 + D.28771;
    D.28767 = cfg->native_code;
    monoeg_g_print ("Method %s emitted at %p to %p (code length %d) [%s]\n", nm, D.28767, D.28831, D.28771, D.28830);
    monoeg_g_free (nm);
  }
  <D.28829>:
  {
    gboolean is_generic;

    is_generic = 0;
    D.28761 = cfg->method;
    D.28790 = BIT_FIELD_REF <*D.28761, 8, 168>;
    D.28834 = D.28790 & 16;
    if (D.28834 != 0) goto <D.28832>; else goto <D.28835>;
    <D.28835>:
    D.28761 = cfg->method;
    D.28836 = mono_method_get_generic_container (D.28761);
    if (D.28836 != 0B) goto <D.28832>; else goto <D.28837>;
    <D.28837>:
    D.28761 = cfg->method;
    D.28838 = D.28761->klass;
    D.28839 = D.28838->generic_container;
    if (D.28839 != 0B) goto <D.28832>; else goto <D.28840>;
    <D.28840>:
    D.28761 = cfg->method;
    D.28838 = D.28761->klass;
    D.28841 = D.28838->generic_class;
    if (D.28841 != 0B) goto <D.28832>; else goto <D.28833>;
    <D.28832>:
    is_generic = 1;
    <D.28833>:
    D.28842 = cfg->generic_sharing_context;
    if (D.28842 != 0B) goto <D.28843>; else goto <D.28844>;
    <D.28843>:
    D.28845 = is_generic == 0;
    D.28846 = (long int) D.28845;
    D.28847 = __builtin_expect (D.28846, 0);
    if (D.28847 != 0) goto <D.28848>; else goto <D.28849>;
    <D.28848>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4170, "is_generic");
    <D.28849>:
    <D.28844>:
  }
  D.28850 = cfg->run_cctors;
  D.28851 = (int) D.28850;
  D.28795 = cfg->dynamic_info;
  if (D.28795 != 0B) goto <D.28853>; else goto <D.28854>;
  <D.28853>:
  D.28795 = cfg->dynamic_info;
  iftmp.107 = D.28795->code_mp;
  goto <D.28855>;
  <D.28854>:
  iftmp.107 = 0B;
  <D.28855>:
  D.28856 = cfg->patch_info;
  D.28767 = cfg->native_code;
  D.28797 = cfg->domain;
  D.28761 = cfg->method;
  mono_arch_patch_code (D.28761, D.28797, D.28767, D.28856, iftmp.107, D.28851);
  D.28761 = cfg->method;
  D.28790 = BIT_FIELD_REF <*D.28761, 8, 168>;
  D.28791 = D.28790 & 2;
  if (D.28791 != 0) goto <D.28857>; else goto <D.28858>;
  <D.28857>:
  mono_using_xdebug.104 = mono_using_xdebug;
  if (mono_using_xdebug.104 != 0) goto <D.28859>; else goto <D.28860>;
  <D.28859>:
  D.28771 = cfg->code_len;
  D.28772 = (int) D.28771;
  D.28782 = cfg->code_size;
  D.28861 = (int) D.28782;
  D.28767 = cfg->native_code;
  mono_domain_code_commit (code_domain, D.28767, D.28861, D.28772);
  goto <D.28862>;
  <D.28860>:
  D.28771 = cfg->code_len;
  D.28772 = (int) D.28771;
  D.28782 = cfg->code_size;
  D.28861 = (int) D.28782;
  D.28767 = cfg->native_code;
  D.28795 = cfg->dynamic_info;
  D.28818 = D.28795->code_mp;
  mono_code_manager_commit (D.28818, D.28767, D.28861, D.28772);
  <D.28862>:
  goto <D.28863>;
  <D.28858>:
  D.28771 = cfg->code_len;
  D.28772 = (int) D.28771;
  D.28782 = cfg->code_size;
  D.28861 = (int) D.28782;
  D.28767 = cfg->native_code;
  mono_domain_code_commit (code_domain, D.28767, D.28861, D.28772);
  <D.28863>:
  D.28761 = cfg->method;
  D.28771 = cfg->code_len;
  D.28772 = (int) D.28771;
  D.28767 = cfg->native_code;
  mono_profiler_code_buffer_new (D.28767, D.28772, 1, D.28761);
  D.28771 = cfg->code_len;
  D.28864 = (int) D.28771;
  D.28767 = cfg->native_code;
  mono_arch_flush_icache (D.28767, D.28864);
  mono_debug_close_method (cfg);
}


mono_dynamic_code_hash_insert (struct MonoDomain * domain, struct MonoMethod * method, struct MonoJitDynamicMethodInfo * ji)
{
  void * D.28865;
  struct GHashTable * D.28866;
  struct GHashTable * D.28869;

  D.28865 = domain->runtime_info;
  D.28866 = MEM[(struct MonoJitDomainInfo *)D.28865].dynamic_code_hash;
  if (D.28866 == 0B) goto <D.28867>; else goto <D.28868>;
  <D.28867>:
  D.28865 = domain->runtime_info;
  D.28869 = monoeg_g_hash_table_new (0B, 0B);
  MEM[(struct MonoJitDomainInfo *)D.28865].dynamic_code_hash = D.28869;
  <D.28868>:
  D.28865 = domain->runtime_info;
  D.28866 = MEM[(struct MonoJitDomainInfo *)D.28865].dynamic_code_hash;
  monoeg_g_hash_table_insert_replace (D.28866, method, ji, 0);
}


mono_postprocess_patches (struct MonoCompile * cfg)
{
  <unnamed type> D.28870;
  const void * D.28871;
  const char * D.28874;
  char * D.28875;
  char * D.28878;
  struct GHashTable * D.28883;
  <unnamed type> D.28888;
  const void * D.28889;
  struct MonoMethod * D.28890;
  unsigned char D.28891;
  unsigned char D.28892;
  struct MonoJumpInfoBBTable * D.28895;
  int D.28896;
  unsigned int D.28897;
  unsigned int D.28898;
  int D.28899;
  struct MonoJitDynamicMethodInfo * D.28900;
  struct MonoCodeManager * D.28901;
  struct MonoDomain * D.28903;
  struct MonoBasicBlock * * D.28904;
  unsigned int i.108;
  unsigned int D.28906;
  struct MonoBasicBlock * * D.28907;
  struct MonoBasicBlock * D.28908;
  int D.28911;
  _Bool D.28912;
  long int D.28913;
  long int D.28914;
  void * * D.28917;
  void * D.28918;
  unsigned char * D.28920;
  int D.28921;
  sizetype D.28922;
  union mono_mutex_t * D.28923;
  _Bool D.28926;
  long int D.28927;
  long int D.28928;
  struct MonoMethod * D.28931;
  void * D.28932;
  struct GHashTable * D.28933;
  struct GSList * D.28936;
  struct GSList * D.28937;
  _Bool D.28940;
  long int D.28941;
  long int D.28942;
  struct MonoJumpInfo * patch_info;
  int i;

  patch_info = cfg->patch_info;
  goto <D.25728>;
  <D.25727>:
  D.28870 = patch_info->type;
  switch (D.28870) <default: <D.25726>, case 1: <D.25711>, case 4: <D.25720>, case 8: <D.25715>>
  <D.25711>:
  {
    struct MonoJitICallInfo * info;

    D.28871 = patch_info->data.target;
    info = mono_find_jit_icall_by_addr (D.28871);
    if (info != 0B) goto <D.28872>; else goto <D.28873>;
    <D.28872>:
    D.28874 = info->name;
    D.28875 = strstr (D.28874, "ves_array_new_va_");
    if (D.28875 == 0B) goto <D.28876>; else goto <D.28877>;
    <D.28876>:
    D.28874 = info->name;
    D.28878 = strstr (D.28874, "ves_array_element_address_");
    if (D.28878 == 0B) goto <D.28879>; else goto <D.28880>;
    <D.28879>:
    patch_info->type = 7;
    D.28874 = info->name;
    patch_info->data.name = D.28874;
    <D.28880>:
    <D.28877>:
    <D.28873>:
    D.28870 = patch_info->type;
    if (D.28870 == 1) goto <D.28881>; else goto <D.28882>;
    <D.28881>:
    D.28883 = cfg->abs_patches;
    if (D.28883 != 0B) goto <D.28884>; else goto <D.28885>;
    <D.28884>:
    {
      struct MonoJumpInfo * abs_ji;

      D.28871 = patch_info->data.target;
      D.28883 = cfg->abs_patches;
      abs_ji = monoeg_g_hash_table_lookup (D.28883, D.28871);
      if (abs_ji != 0B) goto <D.28886>; else goto <D.28887>;
      <D.28886>:
      D.28888 = abs_ji->type;
      patch_info->type = D.28888;
      D.28889 = abs_ji->data.target;
      patch_info->data.target = D.28889;
      <D.28887>:
    }
    <D.28885>:
    <D.28882>:
    goto <D.25714>;
  }
  <D.25715>:
  {
    void * * table;

    D.28890 = cfg->method;
    D.28891 = BIT_FIELD_REF <*D.28890, 8, 168>;
    D.28892 = D.28891 & 2;
    if (D.28892 != 0) goto <D.28893>; else goto <D.28894>;
    <D.28893>:
    D.28895 = patch_info->data.table;
    D.28896 = D.28895->table_size;
    D.28897 = (unsigned int) D.28896;
    D.28898 = D.28897 * 4;
    D.28899 = (int) D.28898;
    D.28900 = cfg->dynamic_info;
    D.28901 = D.28900->code_mp;
    table = mono_code_manager_reserve (D.28901, D.28899);
    goto <D.28902>;
    <D.28894>:
    D.28895 = patch_info->data.table;
    D.28896 = D.28895->table_size;
    D.28897 = (unsigned int) D.28896;
    D.28898 = D.28897 * 4;
    D.28899 = (int) D.28898;
    D.28903 = cfg->domain;
    table = mono_domain_code_reserve (D.28903, D.28899);
    <D.28902>:
    i = 0;
    goto <D.25718>;
    <D.25717>:
    D.28895 = patch_info->data.table;
    D.28904 = D.28895->table;
    i.108 = (unsigned int) i;
    D.28906 = i.108 * 4;
    D.28907 = D.28904 + D.28906;
    D.28908 = *D.28907;
    if (D.28908 != 0B) goto <D.28909>; else goto <D.28910>;
    <D.28909>:
    D.28895 = patch_info->data.table;
    D.28904 = D.28895->table;
    i.108 = (unsigned int) i;
    D.28906 = i.108 * 4;
    D.28907 = D.28904 + D.28906;
    D.28908 = *D.28907;
    D.28911 = D.28908->native_offset;
    D.28912 = D.28911 == 0;
    D.28913 = (long int) D.28912;
    D.28914 = __builtin_expect (D.28913, 0);
    if (D.28914 != 0) goto <D.28915>; else goto <D.28916>;
    <D.28915>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3815, "patch_info->data.table->table [i]->native_offset");
    <D.28916>:
    i.108 = (unsigned int) i;
    D.28906 = i.108 * 4;
    D.28917 = table + D.28906;
    D.28895 = patch_info->data.table;
    D.28904 = D.28895->table;
    i.108 = (unsigned int) i;
    D.28906 = i.108 * 4;
    D.28907 = D.28904 + D.28906;
    D.28908 = *D.28907;
    D.28911 = D.28908->native_offset;
    D.28918 = (void *) D.28911;
    *D.28917 = D.28918;
    goto <D.28919>;
    <D.28910>:
    i.108 = (unsigned int) i;
    D.28906 = i.108 * 4;
    D.28917 = table + D.28906;
    *D.28917 = 0B;
    <D.28919>:
    i = i + 1;
    <D.25718>:
    D.28895 = patch_info->data.table;
    D.28896 = D.28895->table_size;
    if (D.28896 > i) goto <D.25717>; else goto <D.25719>;
    <D.25719>:
    D.28895 = patch_info->data.table;
    D.28895->table = table;
    goto <D.25714>;
  }
  <D.25720>:
  {
    struct MonoJumpList * jlist;
    struct MonoDomain * domain;
    unsigned char * ip;

    domain = cfg->domain;
    D.28920 = cfg->native_code;
    D.28921 = patch_info->ip.i;
    D.28922 = (sizetype) D.28921;
    ip = D.28920 + D.28922;
    {
      int ret;

      D.28923 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.28923);
      if (ret != 0) goto <D.28924>; else goto <D.28925>;
      <D.28924>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.28925>:
      D.28926 = ret != 0;
      D.28927 = (long int) D.28926;
      D.28928 = __builtin_expect (D.28927, 0);
      if (D.28928 != 0) goto <D.28929>; else goto <D.28930>;
      <D.28929>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3835, "ret == 0");
      <D.28930>:
    }
    D.28931 = patch_info->data.method;
    D.28932 = domain->runtime_info;
    D.28933 = MEM[(struct MonoJitDomainInfo *)D.28932].jump_target_hash;
    jlist = monoeg_g_hash_table_lookup (D.28933, D.28931);
    if (jlist == 0B) goto <D.28934>; else goto <D.28935>;
    <D.28934>:
    jlist = mono_domain_alloc0 (domain, 4);
    D.28931 = patch_info->data.method;
    D.28932 = domain->runtime_info;
    D.28933 = MEM[(struct MonoJitDomainInfo *)D.28932].jump_target_hash;
    monoeg_g_hash_table_insert_replace (D.28933, D.28931, jlist, 0);
    <D.28935>:
    D.28936 = jlist->list;
    D.28937 = monoeg_g_slist_prepend (D.28936, ip);
    jlist->list = D.28937;
    {
      int ret;

      D.28923 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.28923);
      if (ret != 0) goto <D.28938>; else goto <D.28939>;
      <D.28938>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.28939>:
      D.28940 = ret != 0;
      D.28941 = (long int) D.28940;
      D.28942 = __builtin_expect (D.28941, 0);
      if (D.28942 != 0) goto <D.28943>; else goto <D.28944>;
      <D.28943>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3842, "ret == 0");
      <D.28944>:
    }
    goto <D.25714>;
  }
  <D.25726>:
  goto <D.25714>;
  <D.25714>:
  patch_info = patch_info->next;
  <D.25728>:
  if (patch_info != 0B) goto <D.25727>; else goto <D.25729>;
  <D.25729>:
}


mini_get_shared_method_full (struct MonoMethod * method, gboolean all_vt, gboolean is_gsharedvt)
{
  unsigned char D.28949;
  unsigned char D.28950;
  struct MonoClass * D.28952;
  struct MonoGenericContainer * D.28953;
  unsigned char D.28955;
  unsigned char D.28956;
  unsigned char D.28957;
  struct MonoGenericContainer * D.28960;
  struct MonoClass * D.28962;
  struct MonoGenericContainer * D.28963;
  int D.28969;
  int D.28971;
  int iftmp.109;
  int D.28978;
  struct MonoGenericInst * D.28984;
  struct MonoGenericInst * D.28985;
  struct MonoGenericInst * D.28991;
  struct MonoGenericInst * D.28992;
  struct MonoClass * D.28995;
  unsigned char D.28996;
  unsigned char D.28997;
  _Bool D.28998;
  long int D.28999;
  long int D.29000;
  struct MonoMethod * D.29003;
  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.28949 = BIT_FIELD_REF <*method, 8, 168>;
      D.28950 = D.28949 & 8;
      if (D.28950 != 0) goto <D.28946>; else goto <D.28951>;
      <D.28951>:
      D.28952 = method->klass;
      D.28953 = D.28952->generic_container;
      if (D.28953 != 0B) goto <D.28954>; else goto <D.28947>;
      <D.28954>:
      D.28949 = BIT_FIELD_REF <*method, 8, 168>;
      D.28955 = D.28949 & 16;
      if (D.28955 == 0) goto <D.28946>; else goto <D.28947>;
      <D.28946>:
      declaring_method = method;
      goto <D.28948>;
      <D.28947>:
      declaring_method = mono_method_get_declaring_generic_method (method);
      <D.28948>:
      D.28956 = BIT_FIELD_REF <*declaring_method, 8, 168>;
      D.28957 = D.28956 & 8;
      if (D.28957 != 0) goto <D.28958>; else goto <D.28959>;
      <D.28958>:
      D.28960 = mono_method_get_generic_container (declaring_method);
      shared_context = D.28960->context;
      goto <D.28961>;
      <D.28959>:
      D.28962 = declaring_method->klass;
      D.28963 = D.28962->generic_container;
      shared_context = D.28963->context;
      <D.28961>:
      if (method != declaring_method) goto <D.28967>; else goto <D.28964>;
      <D.28967>:
      D.28949 = BIT_FIELD_REF <*method, 8, 168>;
      D.28955 = D.28949 & 16;
      if (D.28955 != 0) goto <D.28968>; else goto <D.28964>;
      <D.28968>:
      D.28969 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.28969 == 0) goto <D.28965>; else goto <D.28964>;
      <D.28964>:
      if (is_gsharedvt != 0) goto <D.28965>; else goto <D.28970>;
      <D.28970>:
      D.28971 = mini_is_gsharedvt_sharable_method (method);
      if (D.28971 != 0) goto <D.28965>; else goto <D.28966>;
      <D.28965>:
      {
        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.28973>; else goto <D.28976>;
        <D.28976>:
        if (partial == 0) goto <D.28977>; else goto <D.28974>;
        <D.28977>:
        D.28978 = mini_is_gsharedvt_sharable_method (method);
        if (D.28978 != 0) goto <D.28973>; else goto <D.28974>;
        <D.28973>:
        iftmp.109 = 1;
        goto <D.28975>;
        <D.28974>:
        iftmp.109 = 0;
        <D.28975>:
        gsharedvt = iftmp.109;
        D.28962 = declaring_method->klass;
        class_container = D.28962->generic_container;
        method_container = mono_method_get_generic_container (declaring_method);
        if (context != 0B) goto <D.28979>; else goto <D.28980>;
        <D.28979>:
        inst = context->class_inst;
        goto <D.28981>;
        <D.28980>:
        inst = shared_context.class_inst;
        <D.28981>:
        if (inst != 0B) goto <D.28982>; else goto <D.28983>;
        <D.28982>:
        D.28984 = shared_context.class_inst;
        D.28985 = get_shared_inst (inst, D.28984, class_container, all_vt, gsharedvt);
        shared_context.class_inst = D.28985;
        <D.28983>:
        if (context != 0B) goto <D.28986>; else goto <D.28987>;
        <D.28986>:
        inst = context->method_inst;
        goto <D.28988>;
        <D.28987>:
        inst = shared_context.method_inst;
        <D.28988>:
        if (inst != 0B) goto <D.28989>; else goto <D.28990>;
        <D.28989>:
        D.28991 = shared_context.method_inst;
        D.28992 = get_shared_inst (inst, D.28991, method_container, all_vt, gsharedvt);
        shared_context.method_inst = D.28992;
        <D.28990>:
        partial = 1;
      }
      <D.28966>:
      res = mono_class_inflate_generic_method (declaring_method, &shared_context);
      if (partial == 0) goto <D.28993>; else goto <D.28994>;
      <D.28993>:
      D.28995 = res->klass;
      D.28996 = BIT_FIELD_REF <*D.28995, 8, 192>;
      D.28997 = D.28996 & 8;
      D.28998 = D.28997 != 0;
      D.28999 = (long int) D.28998;
      D.29000 = __builtin_expect (D.28999, 0);
      if (D.29000 != 0) goto <D.29001>; else goto <D.29002>;
      <D.29001>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4777, "!res->klass->is_inflated");
      <D.29002>:
      <D.28994>:
      D.29003 = res;
      return D.29003;
    }
  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.29006;
  unsigned int D.29007;
  unsigned int D.29008;
  struct MonoType * D.29013;
  int D.29014;
  unsigned char D.29016;
  unsigned int i.110;
  unsigned int D.29019;
  struct MonoType * * D.29020;
  struct MonoType * D.29021;
  struct MonoType * D.29024;
  struct MonoType * D.29028;
  int D.29030;
  struct MonoGenericInst * D.29031;
  struct MonoGenericInst * res;
  struct MonoType * * type_argv;
  int i;

  D.29006 = inst->type_argc;
  D.29007 = (unsigned int) D.29006;
  D.29008 = D.29007 * 4;
  type_argv = monoeg_malloc0 (D.29008);
  i = 0;
  goto <D.25953>;
  <D.25952>:
  if (all_vt == 0) goto <D.29012>; else goto <D.29009>;
  <D.29012>:
  D.29013 = inst->type_argv[i];
  D.29014 = mono_type_is_reference (D.29013);
  if (D.29014 != 0) goto <D.29010>; else goto <D.29015>;
  <D.29015>:
  D.29013 = inst->type_argv[i];
  D.29016 = D.29013->type;
  if (D.29016 == 19) goto <D.29010>; else goto <D.29017>;
  <D.29017>:
  D.29013 = inst->type_argv[i];
  D.29016 = D.29013->type;
  if (D.29016 == 30) goto <D.29010>; else goto <D.29009>;
  <D.29010>:
  i.110 = (unsigned int) i;
  D.29019 = i.110 * 4;
  D.29020 = type_argv + D.29019;
  D.29021 = shared_inst->type_argv[i];
  *D.29020 = D.29021;
  goto <D.29011>;
  <D.29009>:
  if (all_vt != 0) goto <D.29022>; else goto <D.29023>;
  <D.29022>:
  i.110 = (unsigned int) i;
  D.29019 = i.110 * 4;
  D.29020 = type_argv + D.29019;
  D.29021 = shared_inst->type_argv[i];
  D.29024 = get_gsharedvt_type (D.29021);
  *D.29020 = D.29024;
  goto <D.29025>;
  <D.29023>:
  if (gsharedvt != 0) goto <D.29026>; else goto <D.29027>;
  <D.29026>:
  i.110 = (unsigned int) i;
  D.29019 = i.110 * 4;
  D.29020 = type_argv + D.29019;
  D.29021 = shared_inst->type_argv[i];
  D.29028 = get_gsharedvt_type (D.29021);
  *D.29020 = D.29028;
  goto <D.29029>;
  <D.29027>:
  i.110 = (unsigned int) i;
  D.29019 = i.110 * 4;
  D.29020 = type_argv + D.29019;
  D.29013 = inst->type_argv[i];
  *D.29020 = D.29013;
  <D.29029>:
  <D.29025>:
  <D.29011>:
  i = i + 1;
  <D.25953>:
  D.29006 = inst->type_argc;
  D.29030 = (int) D.29006;
  if (D.29030 > i) goto <D.25952>; else goto <D.25954>;
  <D.25954>:
  D.29006 = inst->type_argc;
  D.29030 = (int) D.29006;
  res = mono_metadata_get_generic_inst (D.29030, type_argv);
  monoeg_g_free (type_argv);
  D.29031 = res;
  return D.29031;
}


get_gsharedvt_type (struct MonoType * t)
{
  int iftmp.111;
  struct MonoGenericContainer * D.29037;
  struct MonoGenericParamInfo * D.29039;
  _Bool D.29040;
  long int D.29041;
  long int D.29042;
  struct GHashTable * D.29047;
  struct GHashTable * D.29050;
  struct MonoType * D.29053;
  struct MonoImage * D.29055;
  struct MonoGenericParam * par;
  struct MonoGenericParam * copy;
  struct MonoType * res;
  struct MonoImage * image;

  par = t->data.generic_param;
  image = 0B;
  D.29037 = par->owner;
  if (D.29037 == 0B) goto <D.29034>; else goto <D.29038>;
  <D.29038>:
  D.29039 = &MEM[(struct MonoGenericParamFull *)par].info;
  if (D.29039 == 0B) goto <D.29034>; else goto <D.29035>;
  <D.29034>:
  iftmp.111 = 1;
  goto <D.29036>;
  <D.29035>:
  iftmp.111 = 0;
  <D.29036>:
  D.29040 = iftmp.111 != 0;
  D.29041 = (long int) D.29040;
  D.29042 = __builtin_expect (D.29041, 0);
  if (D.29042 != 0) goto <D.29043>; else goto <D.29044>;
  <D.29043>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4607, "mono_generic_param_info (par)");
  <D.29044>:
  D.29037 = par->owner;
  if (D.29037 != 0B) goto <D.29045>; else goto <D.29046>;
  <D.29045>:
  D.29037 = par->owner;
  image = D.29037->image;
  mono_image_lock (image);
  D.29047 = image->gsharedvt_types;
  if (D.29047 == 0B) goto <D.29048>; else goto <D.29049>;
  <D.29048>:
  D.29050 = monoeg_g_hash_table_new (0B, 0B);
  image->gsharedvt_types = D.29050;
  <D.29049>:
  D.29047 = image->gsharedvt_types;
  res = monoeg_g_hash_table_lookup (D.29047, par);
  mono_image_unlock (image);
  if (res != 0B) goto <D.29051>; else goto <D.29052>;
  <D.29051>:
  D.29053 = res;
  return D.29053;
  <D.29052>:
  copy = mono_image_alloc0 (image, 32);
  memcpy (copy, par, 32);
  goto <D.29054>;
  <D.29046>:
  copy = monoeg_g_memdup (par, 32);
  <D.29054>:
  copy->owner = 0B;
  D.29055 = mono_defaults.corlib;
  copy->image = D.29055;
  copy->serial = 1;
  res = mono_metadata_type_dup (0B, t);
  res->data.generic_param = copy;
  D.29037 = par->owner;
  if (D.29037 != 0B) goto <D.29056>; else goto <D.29057>;
  <D.29056>:
  mono_image_lock (image);
  D.29047 = image->gsharedvt_types;
  monoeg_g_hash_table_insert_replace (D.29047, par, res, 0);
  mono_image_unlock (image);
  <D.29057>:
  D.29053 = res;
  return D.29053;
}


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

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


mini_init_gsctx (struct MonoGenericContext * context, struct MonoGenericSharingContext * gsctx)
{
  struct MonoGenericInst * D.29061;
  <unnamed-unsigned:22> D.29064;
  unsigned int D.29065;
  unsigned int D.29066;
  void * D.29067;
  unsigned char D.29068;
  _Bool D.29069;
  _Bool D.29070;
  _Bool D.29071;
  struct MonoGenericParam * D.29074;
  short unsigned int D.29075;
  gboolean * D.29078;
  unsigned int i.112;
  unsigned int D.29080;
  gboolean * D.29081;
  int D.29082;
  struct MonoGenericInst * D.29083;
  void * D.29086;
  unsigned char D.29087;
  _Bool D.29088;
  _Bool D.29089;
  _Bool D.29090;
  struct MonoGenericParam * D.29093;
  short unsigned int D.29094;
  gboolean * D.29097;
  gboolean * D.29098;
  struct MonoGenericInst * inst;
  int i;

  memset (gsctx, 0, 8);
  D.29061 = context->class_inst;
  if (D.29061 != 0B) goto <D.29062>; else goto <D.29063>;
  <D.29062>:
  inst = context->class_inst;
  D.29064 = inst->type_argc;
  D.29065 = (unsigned int) D.29064;
  D.29066 = D.29065 * 4;
  D.29067 = monoeg_malloc0 (D.29066);
  gsctx->var_is_vt = D.29067;
  i = 0;
  goto <D.25980>;
  <D.25979>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.29068 = type->type;
    D.29069 = D.29068 == 19;
    D.29070 = D.29068 == 30;
    D.29071 = D.29069 | D.29070;
    if (D.29071 != 0) goto <D.29072>; else goto <D.29073>;
    <D.29072>:
    D.29074 = type->data.generic_param;
    D.29075 = D.29074->serial;
    if (D.29075 == 1) goto <D.29076>; else goto <D.29077>;
    <D.29076>:
    D.29078 = gsctx->var_is_vt;
    i.112 = (unsigned int) i;
    D.29080 = i.112 * 4;
    D.29081 = D.29078 + D.29080;
    *D.29081 = 1;
    <D.29077>:
    <D.29073>:
  }
  i = i + 1;
  <D.25980>:
  D.29064 = inst->type_argc;
  D.29082 = (int) D.29064;
  if (D.29082 > i) goto <D.25979>; else goto <D.25981>;
  <D.25981>:
  <D.29063>:
  D.29083 = context->method_inst;
  if (D.29083 != 0B) goto <D.29084>; else goto <D.29085>;
  <D.29084>:
  inst = context->method_inst;
  D.29064 = inst->type_argc;
  D.29065 = (unsigned int) D.29064;
  D.29066 = D.29065 * 4;
  D.29086 = monoeg_malloc0 (D.29066);
  gsctx->mvar_is_vt = D.29086;
  i = 0;
  goto <D.25984>;
  <D.25983>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.29087 = type->type;
    D.29088 = D.29087 == 19;
    D.29089 = D.29087 == 30;
    D.29090 = D.29088 | D.29089;
    if (D.29090 != 0) goto <D.29091>; else goto <D.29092>;
    <D.29091>:
    D.29093 = type->data.generic_param;
    D.29094 = D.29093->serial;
    if (D.29094 == 1) goto <D.29095>; else goto <D.29096>;
    <D.29095>:
    D.29097 = gsctx->mvar_is_vt;
    i.112 = (unsigned int) i;
    D.29080 = i.112 * 4;
    D.29098 = D.29097 + D.29080;
    *D.29098 = 1;
    <D.29096>:
    <D.29092>:
  }
  i = i + 1;
  <D.25984>:
  D.29064 = inst->type_argc;
  D.29082 = (int) D.29064;
  if (D.29082 > i) goto <D.25983>; else goto <D.25985>;
  <D.25985>:
  <D.29085>:
}


mini_method_compile (struct MonoMethod * method, guint32 opts, struct MonoDomain * domain, JitFlags flags, int parts)
{
  unsigned int D.29099;
  _Bool D.29100;
  unsigned int D.29101;
  _Bool D.29102;
  unsigned int D.29103;
  _Bool D.29104;
  <unnamed type> D.29105;
  unsigned int D.29106;
  int iftmp.113;
  struct MonoClass * D.29117;
  int D.29118;
  unsigned int D.29120;
  unsigned char D.29122;
  unsigned char D.29123;
  struct MonoGenericContainer * D.29125;
  struct MonoGenericClass * D.29127;
  int D.29129;
  int iftmp.114;
  int D.29134;
  int D.29137;
  long unsigned int D.29143;
  long unsigned int D.29144;
  int D.29146;
  long unsigned int D.29149;
  long unsigned int D.29150;
  int D.29151;
  int D.29154;
  int D.29161;
  int D.29164;
  _Bool D.29165;
  long int D.29166;
  long int D.29167;
  _Bool D.29175;
  long int D.29176;
  long int D.29177;
  struct MonoMethod * D.29181;
  struct MonoMethodHeader * D.29182;
  struct MonoMemPool * D.29183;
  <unnamed type> D.29184;
  unsigned char D.29185;
  <unnamed-unsigned:1> D.29186;
  int mini_verbose.115;
  unsigned int mini_verbose.116;
  unsigned char D.29189;
  <unnamed-unsigned:1> D.29190;
  unsigned char D.29191;
  <unnamed-unsigned:1> D.29192;
  <unnamed-unsigned:1> D.29193;
  int D.29194;
  unsigned char D.29195;
  <unnamed-unsigned:1> D.29196;
  int D.29197;
  unsigned char D.29198;
  <unnamed-unsigned:1> D.29199;
  int D.29200;
  unsigned char D.29201;
  <unnamed-unsigned:1> D.29202;
  struct MonoGenericSharingContext * D.29205;
  unsigned char D.29206;
  <unnamed-unsigned:1> D.29207;
  struct GHashTable * D.29208;
  unsigned char D.29209;
  unsigned char D.29210;
  struct GPtrArray * D.29213;
  unsigned char D.29216;
  unsigned char D.29217;
  struct MonoCompile * D.29224;
  struct MonoGenericSharingContext * D.29227;
  int D.29230;
  unsigned char D.29234;
  _Bool D.29235;
  long int D.29236;
  long int D.29237;
  unsigned char D.29243;
  unsigned char D.29244;
  _Bool D.29245;
  long int D.29246;
  long int D.29247;
  _Bool D.29253;
  long int D.29254;
  long int D.29255;
  const char * D.29260;
  gchar * D.29261;
  unsigned char D.29268;
  unsigned int D.29269;
  const char * D.29271;
  gchar * D.29272;
  int D.29275;
  unsigned int D.29278;
  unsigned int D.29279;
  unsigned int D.29280;
  unsigned int D.29281;
  unsigned int D.29282;
  int mono_using_xdebug.117;
  unsigned int D.29288;
  const gchar * D.29289;
  char * D.29295;
  char * D.29297;
  int D.29298;
  int D.26024;
  const gchar * D.29301;
  <unnamed-unsigned:15> D.29304;
  unsigned int D.29305;
  unsigned int D.29306;
  struct MonoMemPool * D.29307;
  void * D.29308;
  unsigned int D.29309;
  const char * iftmp.118;
  int D.29316;
  const char * iftmp.119;
  unsigned int D.29322;
  unsigned int D.29325;
  int count.120;
  int count.121;
  struct MonoExceptionClause * D.29328;
  unsigned char D.29331;
  unsigned char D.29332;
  unsigned char D.29335;
  unsigned char D.29336;
  unsigned int D.29339;
  struct MonoRegState * D.29342;
  unsigned char D.29343;
  unsigned char D.29344;
  struct MonoRegState * D.29347;
  int D.29348;
  unsigned int D.29349;
  unsigned int D.29350;
  int D.29353;
  struct MonoDebugOptions * D.29356;
  int D.29357;
  unsigned int D.29360;
  unsigned int D.29365;
  _Bool D.29372;
  long int D.29373;
  long int D.29374;
  int D.29379;
  unsigned int D.29380;
  unsigned int D.29381;
  unsigned int D.29382;
  int D.29383;
  struct MonoInst * D.29386;
  unsigned char D.29389;
  unsigned char D.29390;
  int D.29391;
  struct MonoInst * D.29392;
  int D.29393;
  int D.29394;
  const unsigned char * D.29395;
  int D.29396;
  struct MonoBasicBlock * D.29397;
  struct MonoInst * D.29398;
  unsigned int D.29402;
  unsigned int D.29403;
  unsigned int D.29406;
  unsigned int D.29409;
  unsigned int D.29412;
  unsigned int D.29415;
  unsigned int D.29422;
  unsigned int D.29424;
  unsigned int D.29425;
  void * D.29426;
  struct MonoBasicBlock * * D.29427;
  struct MonoBasicBlock * D.29428;
  int dfn.122;
  int D.29430;
  unsigned int D.29431;
  unsigned int D.29434;
  unsigned int D.29435;
  unsigned int D.29436;
  unsigned int D.29439;
  int D.29444;
  struct MonoInst * D.29445;
  struct MonoBasicBlock * * D.29446;
  struct MonoBasicBlock * D.29447;
  short int D.29448;
  unsigned int D.29451;
  unsigned int D.29455;
  unsigned int D.29456;
  unsigned int D.29465;
  unsigned int D.29466;
  unsigned char D.29469;
  unsigned int D.29478;
  unsigned int D.29479;
  unsigned int D.29490;
  unsigned int D.29491;
  unsigned int D.29494;
  void * D.29503;
  unsigned int D.29515;
  struct MonoInst * D.29518;
  unsigned char D.29521;
  _Bool D.29522;
  long int D.29523;
  long int D.29524;
  unsigned int D.29527;
  signed int D.29528;
  int D.29529;
  long long int D.29530;
  signed int D.29531;
  signed int D.29532;
  unsigned int D.29533;
  unsigned int D.29536;
  unsigned int D.29541;
  unsigned int D.29542;
  void * D.29549;
  unsigned int D.29550;
  unsigned int D.29551;
  regmask_t * D.29554;
  int need_local_opts.123;
  struct MonoInst * D.29569;
  short unsigned int D.29572;
  short unsigned int D.29573;
  _Bool D.29574;
  short unsigned int D.29575;
  _Bool D.29576;
  _Bool D.29577;
  short unsigned int D.29579;
  short unsigned int D.29580;
  struct MonoBasicBlock * * D.29581;
  struct MonoBasicBlock * * D.29582;
  struct MonoBasicBlock * D.29583;
  struct MonoBasicBlock * D.29586;
  short unsigned int D.29593;
  short unsigned int D.29594;
  _Bool D.29595;
  short unsigned int D.29596;
  _Bool D.29597;
  _Bool D.29598;
  short unsigned int D.29600;
  struct MonoInst * D.29602;
  struct MonoInst * D.29604;
  unsigned char D.29605;
  struct MonoBasicBlock * D.29606;
  struct MonoBasicBlock * D.29608;
  unsigned int D.29609;
  unsigned int D.29610;
  short unsigned int D.29611;
  int D.29616;
  unsigned int D.29619;
  struct MonoJitInfo * D.29626;
  unsigned char D.29627;
  unsigned char D.29628;
  struct MonoMethodVar * D.29631;
  unsigned int i.124;
  unsigned int D.29633;
  struct MonoMethodVar * D.29634;
  unsigned int D.29635;
  int D.29636;
  unsigned int i.125;
  char * D.29642;
  int D.29643;
  unsigned char * D.29644;
  struct MonoDomain * D.29647;
  union mono_mutex_t * D.29648;
  _Bool D.29651;
  long int D.29652;
  long int D.29653;
  struct MonoJitInfo * D.29656;
  unsigned char D.29657;
  struct MonoJitDynamicMethodInfo * D.29660;
  _Bool D.29663;
  long int D.29664;
  long int D.29665;
  struct MonoPerfCounters * mono_perfcounters.126;
  unsigned int D.29669;
  unsigned int D.29670;
  unsigned int D.29671;
  unsigned int D.29672;
  int D.29673;
  unsigned int D.29674;
  unsigned int D.29675;
  int D.29676;
  int D.29677;
  int D.29680;
  char * D.29683;
  const char * D.29684;
  const char * D.29685;
  gchar * D.29686;
  int D.29687;
  unsigned int D.29688;
  unsigned int D.29689;
  int D.29690;
  char * D.29695;
  gchar * D.29696;
  int D.29697;
  unsigned int D.29698;
  unsigned int D.29699;
  int D.29700;
  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.29099 = flags & 1;
      D.29100 = D.29099 != 0;
      run_cctors = (gboolean) D.29100;
      D.29101 = flags & 2;
      D.29102 = D.29101 != 0;
      compile_aot = (gboolean) D.29102;
      D.29103 = flags & 4;
      D.29104 = D.29103 != 0;
      full_aot = (gboolean) D.29104;
      InterlockedIncrement (&mono_jit_stats.methods_compiled);
      D.29105 = mono_profiler_get_events ();
      D.29106 = D.29105 & 16;
      if (D.29106 != 0) goto <D.29107>; else goto <D.29108>;
      <D.29107>:
      mono_profiler_method_jit (method);
      <D.29108>:
      if (0 != 0) goto <D.29109>; else goto <D.29110>;
      <D.29109>:
      <D.29110>:
      if (compile_aot != 0) goto <D.29111>; else goto <D.29112>;
      <D.29111>:
      D.29117 = method->klass;
      D.29118 = mono_class_generic_sharing_enabled (D.29117);
      if (D.29118 != 0) goto <D.29119>; else goto <D.29114>;
      <D.29119>:
      D.29120 = opts & 33554432;
      if (D.29120 != 0) goto <D.29121>; else goto <D.29114>;
      <D.29121>:
      D.29122 = BIT_FIELD_REF <*method, 8, 168>;
      D.29123 = D.29122 & 8;
      if (D.29123 != 0) goto <D.29115>; else goto <D.29124>;
      <D.29124>:
      D.29117 = method->klass;
      D.29125 = D.29117->generic_container;
      if (D.29125 != 0B) goto <D.29115>; else goto <D.29126>;
      <D.29126>:
      D.29117 = method->klass;
      D.29127 = D.29117->generic_class;
      if (D.29127 == 0B) goto <D.29128>; else goto <D.29114>;
      <D.29128>:
      D.29129 = mono_method_is_generic_sharable_full (method, 1, 0, 0);
      if (D.29129 != 0) goto <D.29115>; else goto <D.29114>;
      <D.29115>:
      iftmp.113 = 1;
      goto <D.29116>;
      <D.29114>:
      iftmp.113 = 0;
      <D.29116>:
      try_generic_shared = iftmp.113;
      goto <D.29130>;
      <D.29112>:
      D.29117 = method->klass;
      D.29134 = mono_class_generic_sharing_enabled (D.29117);
      if (D.29134 != 0) goto <D.29135>; else goto <D.29132>;
      <D.29135>:
      D.29120 = opts & 33554432;
      if (D.29120 != 0) goto <D.29136>; else goto <D.29132>;
      <D.29136>:
      D.29137 = mono_method_is_generic_sharable (method, 0);
      if (D.29137 != 0) goto <D.29138>; else goto <D.29132>;
      <D.29138>:
      iftmp.114 = 1;
      goto <D.29133>;
      <D.29132>:
      iftmp.114 = 0;
      <D.29133>:
      try_generic_shared = iftmp.114;
      <D.29130>:
      D.29120 = opts & 33554432;
      if (D.29120 != 0) goto <D.29139>; else goto <D.29140>;
      <D.29139>:
      if (try_generic_shared != 0) goto <D.29141>; else goto <D.29142>;
      <D.29141>:
      D.29143 = mono_stats.generics_sharable_methods;
      D.29144 = D.29143 + 1;
      mono_stats.generics_sharable_methods = D.29144;
      goto <D.29145>;
      <D.29142>:
      D.29146 = mono_method_is_generic_impl (method);
      if (D.29146 != 0) goto <D.29147>; else goto <D.29148>;
      <D.29147>:
      D.29149 = mono_stats.generics_unsharable_methods;
      D.29150 = D.29149 + 1;
      mono_stats.generics_unsharable_methods = D.29150;
      <D.29148>:
      <D.29145>:
      <D.29140>:
      D.29151 = mini_is_gsharedvt_sharable_method (method);
      if (D.29151 != 0) goto <D.29152>; else goto <D.29153>;
      <D.29152>:
      D.29154 = mono_debug_count ();
      if (D.29154 == 0) goto <D.29155>; else goto <D.29156>;
      <D.29155>:
      try_generic_shared = 0;
      <D.29156>:
      if (compile_aot != 0) goto <D.29157>; else goto <D.29158>;
      <D.29157>:
      try_generic_shared = 0;
      <D.29158>:
      <D.29153>:
      D.29161 = is_gsharedvt_method (method);
      if (D.29161 != 0) goto <D.29159>; else goto <D.29162>;
      <D.29162>:
      if (compile_aot != 0) goto <D.29163>; else goto <D.29160>;
      <D.29163>:
      D.29164 = is_open_method (method);
      if (D.29164 != 0) goto <D.29159>; else goto <D.29160>;
      <D.29159>:
      method_is_gshared = 1;
      D.29165 = compile_aot == 0;
      D.29166 = (long int) D.29165;
      D.29167 = __builtin_expect (D.29166, 0);
      if (D.29167 != 0) goto <D.29168>; else goto <D.29169>;
      <D.29168>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4884, "compile_aot");
      <D.29169>:
      try_generic_shared = 1;
      <D.29160>:
      restart_compile:
      if (method_is_gshared != 0) goto <D.29170>; else goto <D.29171>;
      <D.29170>:
      method_to_compile = method;
      goto <D.29172>;
      <D.29171>:
      if (try_generic_shared != 0) goto <D.29173>; else goto <D.29174>;
      <D.29173>:
      method_to_compile = mini_get_shared_method (method);
      D.29175 = method_to_compile == 0B;
      D.29176 = (long int) D.29175;
      D.29177 = __builtin_expect (D.29176, 0);
      if (D.29177 != 0) goto <D.29178>; else goto <D.29179>;
      <D.29178>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4898, "method_to_compile");
      <D.29179>:
      goto <D.29180>;
      <D.29174>:
      method_to_compile = method;
      <D.29180>:
      <D.29172>:
      cfg = monoeg_malloc0 (688);
      cfg->method = method_to_compile;
      D.29181 = cfg->method;
      D.29182 = mono_method_get_header (D.29181);
      cfg->header = D.29182;
      D.29183 = mono_mempool_new ();
      cfg->mempool = D.29183;
      cfg->opt = opts;
      D.29184 = mono_profiler_get_events ();
      cfg->prof_options = D.29184;
      D.29185 = (unsigned char) run_cctors;
      D.29186 = (<unnamed-unsigned:1>) D.29185;
      cfg->run_cctors = D.29186;
      cfg->domain = domain;
      mini_verbose.115 = mini_verbose;
      mini_verbose.116 = (unsigned int) mini_verbose.115;
      cfg->verbose_level = mini_verbose.116;
      D.29189 = (unsigned char) compile_aot;
      D.29190 = (<unnamed-unsigned:1>) D.29189;
      cfg->compile_aot = D.29190;
      D.29191 = (unsigned char) full_aot;
      D.29192 = (<unnamed-unsigned:1>) D.29191;
      cfg->full_aot = D.29192;
      D.29193 = method->skip_visibility;
      cfg->skip_visibility = D.29193;
      cfg->orig_method = method;
      D.29194 = debug_options.gen_seq_points;
      D.29195 = (unsigned char) D.29194;
      D.29196 = (<unnamed-unsigned:1>) D.29195;
      cfg->gen_seq_points = D.29196;
      D.29197 = debug_options.explicit_null_checks;
      D.29198 = (unsigned char) D.29197;
      D.29199 = (<unnamed-unsigned:1>) D.29198;
      cfg->explicit_null_checks = D.29199;
      D.29200 = debug_options.soft_breakpoints;
      D.29201 = (unsigned char) D.29200;
      D.29202 = (<unnamed-unsigned:1>) D.29201;
      cfg->soft_breakpoints = D.29202;
      if (try_generic_shared != 0) goto <D.29203>; else goto <D.29204>;
      <D.29203>:
      D.29205 = &cfg->gsctx;
      cfg->generic_sharing_context = D.29205;
      <D.29204>:
      D.29206 = (unsigned char) try_llvm;
      D.29207 = (<unnamed-unsigned:1>) D.29206;
      cfg->compile_llvm = D.29207;
      D.29208 = monoeg_g_hash_table_new (0B, 0B);
      cfg->token_info_hash = D.29208;
      D.29209 = BIT_FIELD_REF <*cfg, 8, 3424>;
      D.29210 = D.29209 & 32;
      if (D.29210 != 0) goto <D.29211>; else goto <D.29212>;
      <D.29211>:
      D.29213 = monoeg_g_ptr_array_new ();
      cfg->seq_points = D.29213;
      <D.29212>:
      D.29216 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.29217 = D.29216 & 64;
      if (D.29217 != 0) goto <D.29218>; else goto <D.29219>;
      <D.29218>:
      if (try_generic_shared == 0) goto <D.29220>; else goto <D.29221>;
      <D.29220>:
      D.29122 = BIT_FIELD_REF <*method, 8, 168>;
      D.29123 = D.29122 & 8;
      if (D.29123 != 0) goto <D.29214>; else goto <D.29222>;
      <D.29222>:
      D.29117 = method->klass;
      D.29125 = D.29117->generic_container;
      if (D.29125 != 0B) goto <D.29214>; else goto <D.29223>;
      <D.29223>:
      if (method_is_gshared != 0) goto <D.29214>; else goto <D.29215>;
      <D.29214>:
      cfg->exception_type = 11;
      D.29224 = cfg;
      return D.29224;
      <D.29215>:
      <D.29221>:
      <D.29219>:
      D.29227 = cfg->generic_sharing_context;
      if (D.29227 != 0B) goto <D.29228>; else goto <D.29229>;
      <D.29228>:
      D.29230 = mini_is_gsharedvt_sharable_method (method);
      if (D.29230 != 0) goto <D.29225>; else goto <D.29231>;
      <D.29231>:
      if (method_is_gshared != 0) goto <D.29225>; else goto <D.29226>;
      <D.29225>:
      {
        struct MonoMethodInflated * inflated;
        struct MonoGenericContext * context;

        if (method_is_gshared != 0) goto <D.29232>; else goto <D.29233>;
        <D.29232>:
        D.29122 = BIT_FIELD_REF <*method, 8, 168>;
        D.29234 = D.29122 & 16;
        D.29235 = D.29234 == 0;
        D.29236 = (long int) D.29235;
        D.29237 = __builtin_expect (D.29236, 0);
        if (D.29237 != 0) goto <D.29238>; else goto <D.29239>;
        <D.29238>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4939, "method->is_inflated");
        <D.29239>:
        inflated = method;
        context = &inflated->context;
        D.29165 = compile_aot == 0;
        D.29166 = (long int) D.29165;
        D.29167 = __builtin_expect (D.29166, 0);
        if (D.29167 != 0) goto <D.29240>; else goto <D.29241>;
        <D.29240>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4944, "compile_aot");
        <D.29241>:
        goto <D.29242>;
        <D.29233>:
        D.29243 = BIT_FIELD_REF <*method_to_compile, 8, 168>;
        D.29244 = D.29243 & 16;
        D.29245 = D.29244 == 0;
        D.29246 = (long int) D.29245;
        D.29247 = __builtin_expect (D.29246, 0);
        if (D.29247 != 0) goto <D.29248>; else goto <D.29249>;
        <D.29248>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4946, "method_to_compile->is_inflated");
        <D.29249>:
        inflated = method_to_compile;
        context = &inflated->context;
        <D.29242>:
        D.29205 = &cfg->gsctx;
        mini_init_gsctx (context, D.29205);
        cfg->gsharedvt = 1;
        cfg->disable_llvm = 1;
      }
      <D.29226>:
      <D.29229>:
      D.29227 = cfg->generic_sharing_context;
      if (D.29227 != 0B) goto <D.29250>; else goto <D.29251>;
      <D.29250>:
      method_to_register = method_to_compile;
      goto <D.29252>;
      <D.29251>:
      D.29253 = method != method_to_compile;
      D.29254 = (long int) D.29253;
      D.29255 = __builtin_expect (D.29254, 0);
      if (D.29255 != 0) goto <D.29256>; else goto <D.29257>;
      <D.29256>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4961, "method == method_to_compile");
      <D.29257>:
      method_to_register = method;
      <D.29252>:
      cfg->method_to_register = method_to_register;
      mono_error_init (&err);
      D.29181 = cfg->method;
      sig = mono_method_signature_checked (D.29181, &err);
      if (sig == 0B) goto <D.29258>; else goto <D.29259>;
      <D.29258>:
      cfg->exception_type = 7;
      D.29260 = mono_error_get_message (&err);
      D.29261 = monoeg_strdup (D.29260);
      cfg->exception_message = D.29261;
      mono_error_cleanup (&err);
      if (0 != 0) goto <D.29262>; else goto <D.29263>;
      <D.29262>:
      <D.29263>:
      D.29224 = cfg;
      return D.29224;
      <D.29259>:
      header = cfg->header;
      if (header == 0B) goto <D.29264>; else goto <D.29265>;
      <D.29264>:
      {
        struct MonoLoaderError * error;

        error = mono_loader_get_last_error ();
        if (error != 0B) goto <D.29266>; else goto <D.29267>;
        <D.29266>:
        D.29268 = error->exception_type;
        D.29269 = (unsigned int) D.29268;
        cfg->exception_type = D.29269;
        goto <D.29270>;
        <D.29267>:
        cfg->exception_type = 3;
        D.29181 = cfg->method;
        D.29271 = D.29181->name;
        D.29272 = monoeg_g_strdup_printf ("Missing or incorrect header for method %s", D.29271);
        cfg->exception_message = D.29272;
        <D.29270>:
        if (0 != 0) goto <D.29273>; else goto <D.29274>;
        <D.29273>:
        <D.29274>:
        D.29224 = cfg;
        return D.29224;
      }
      <D.29265>:
      D.29275 = debug_options.mdb_optimizations;
      if (D.29275 != 0) goto <D.29276>; else goto <D.29277>;
      <D.29276>:
      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.29278 = cfg->opt;
      D.29279 = D.29278 & 4294967231;
      cfg->opt = D.29279;
      D.29278 = cfg->opt;
      D.29280 = D.29278 & 4294967291;
      cfg->opt = D.29280;
      D.29278 = cfg->opt;
      D.29281 = D.29278 & 4294967263;
      cfg->opt = D.29281;
      D.29278 = cfg->opt;
      D.29282 = D.29278 & 4294967279;
      cfg->opt = D.29282;
      cfg->disable_out_of_line_bblocks = 1;
      <D.29277>:
      mono_using_xdebug.117 = mono_using_xdebug;
      if (mono_using_xdebug.117 != 0) goto <D.29284>; else goto <D.29285>;
      <D.29284>:
      cfg->disable_reuse_registers = 1;
      cfg->disable_reuse_stack_slots = 1;
      cfg->extend_live_ranges = 1;
      cfg->compute_precise_live_ranges = 1;
      <D.29285>:
      mini_gc_init_cfg (cfg);
      if (0 != 0) goto <D.29286>; else goto <D.29287>;
      <D.29286>:
      D.29278 = cfg->opt;
      D.29288 = D.29278 | 262144;
      cfg->opt = D.29288;
      <D.29287>:
      D.29289 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
      if (D.29289 != 0B) goto <D.29290>; else goto <D.29291>;
      <D.29290>:
      {
        const char * name;

        name = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
        D.29295 = __builtin_strchr (name, 46);
        if (D.29295 > name) goto <D.29292>; else goto <D.29296>;
        <D.29296>:
        D.29297 = __builtin_strchr (name, 58);
        if (D.29297 != 0B) goto <D.29292>; else goto <D.29293>;
        <D.29292>:
        {
          struct MonoMethodDesc * desc;

          desc = mono_method_desc_new (name, 1);
          D.29181 = cfg->method;
          D.29298 = mono_method_desc_full_match (desc, D.29181);
          if (D.29298 != 0) goto <D.29299>; else goto <D.29300>;
          <D.29299>:
          cfg->verbose_level = 4;
          <D.29300>:
          mono_method_desc_free (desc);
        }
        goto <D.29294>;
        <D.29293>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.29301 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
          D.29181 = cfg->method;
          D.29271 = D.29181->name;
          D.26024 = __builtin_strcmp (D.29271, D.29301);
        }
        if (D.26024 == 0) goto <D.29302>; else goto <D.29303>;
        <D.29302>:
        cfg->verbose_level = 4;
        <D.29303>:
        <D.29294>:
      }
      <D.29291>:
      ip = header->code;
      D.29304 = header->max_stack;
      D.29305 = (unsigned int) D.29304;
      D.29306 = D.29305 * 16;
      D.29307 = cfg->mempool;
      D.29308 = mono_mempool_alloc0 (D.29307, D.29306);
      cfg->intvars = D.29308;
      D.29309 = cfg->verbose_level;
      if (D.29309 != 0) goto <D.29310>; else goto <D.29311>;
      <D.29310>:
      {
        char * method_name;

        method_name = mono_method_full_name (method, 1);
        D.29227 = cfg->generic_sharing_context;
        if (D.29227 != 0B) goto <D.29315>; else goto <D.29313>;
        <D.29315>:
        D.29316 = cfg->gsharedvt;
        if (D.29316 == 0) goto <D.29317>; else goto <D.29313>;
        <D.29317>:
        iftmp.118 = "gshared ";
        goto <D.29314>;
        <D.29313>:
        iftmp.118 = "";
        <D.29314>:
        D.29316 = cfg->gsharedvt;
        if (D.29316 != 0) goto <D.29319>; else goto <D.29320>;
        <D.29319>:
        iftmp.119 = "gsharedvt ";
        goto <D.29321>;
        <D.29320>:
        iftmp.119 = "";
        <D.29321>:
        monoeg_g_print ("converting %s%s%smethod %s\n", "", iftmp.119, iftmp.118, method_name);
        monoeg_g_free (method_name);
      }
      <D.29311>:
      D.29278 = cfg->opt;
      D.29322 = D.29278 & 786432;
      if (D.29322 != 0) goto <D.29323>; else goto <D.29324>;
      <D.29323>:
      D.29278 = cfg->opt;
      D.29325 = D.29278 | 2097152;
      cfg->opt = D.29325;
      <D.29324>:
      {
        static int count = 0;

        count.120 = count;
        count.121 = count.120 + 1;
        count = count.121;
      }
      D.29328 = header->clauses;
      if (D.29328 != 0B) goto <D.29329>; else goto <D.29330>;
      <D.29329>:
      cfg->globalra = 0;
      <D.29330>:
      D.29181 = cfg->method;
      D.29331 = BIT_FIELD_REF <*D.29181, 8, 160>;
      D.29332 = D.29331 & 124;
      if (D.29332 == 20) goto <D.29333>; else goto <D.29334>;
      <D.29333>:
      cfg->globalra = 0;
      <D.29334>:
      D.29181 = cfg->method;
      D.29335 = BIT_FIELD_REF <*D.29181, 8, 168>;
      D.29336 = D.29335 & 1;
      if (D.29336 != 0) goto <D.29337>; else goto <D.29338>;
      <D.29337>:
      cfg->globalra = 0;
      <D.29338>:
      D.29339 = header->code_size;
      if (D.29339 > 5000) goto <D.29340>; else goto <D.29341>;
      <D.29340>:
      cfg->globalra = 0;
      <D.29341>:
      D.29342 = mono_regstate_new ();
      cfg->rs = D.29342;
      D.29343 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.29344 = D.29343 & 16;
      if (D.29344 != 0) goto <D.29345>; else goto <D.29346>;
      <D.29345>:
      D.29347 = cfg->rs;
      D.29347->next_vreg = 16;
      <D.29346>:
      D.29347 = cfg->rs;
      D.29348 = D.29347->next_vreg;
      D.29349 = (unsigned int) D.29348;
      cfg->next_vreg = D.29349;
      D.29278 = cfg->opt;
      D.29350 = D.29278 & 2097152;
      if (D.29350 != 0) goto <D.29351>; else goto <D.29352>;
      <D.29351>:
      cfg->enable_extended_bblocks = 0;
      <D.29352>:
      D.29181 = cfg->method;
      D.29353 = mono_compile_is_broken (cfg, D.29181, 1);
      if (D.29353 != 0) goto <D.29354>; else goto <D.29355>;
      <D.29354>:
      D.29356 = mini_get_debug_options ();
      D.29357 = D.29356->break_on_unverified;
      if (D.29357 != 0) goto <D.29358>; else goto <D.29359>;
      <D.29358>:
      __asm__ __volatile__("int $03");
      <D.29359>:
      D.29224 = cfg;
      return D.29224;
      <D.29355>:
      mono_compile_create_vars (cfg);
      D.29278 = cfg->opt;
      D.29360 = D.29278 & 4294443007;
      cfg->opt = D.29360;
      i = mono_method_to_ir (cfg, method_to_compile, 0B, 0B, 0B, 0B, 0B, 0, 0);
      if (i < 0) goto <D.29361>; else goto <D.29362>;
      <D.29361>:
      if (try_generic_shared != 0) goto <D.29363>; else goto <D.29364>;
      <D.29363>:
      D.29365 = cfg->exception_type;
      if (D.29365 == 11) goto <D.29366>; else goto <D.29367>;
      <D.29366>:
      if (compile_aot != 0) goto <D.29368>; else goto <D.29369>;
      <D.29368>:
      if (0 != 0) goto <D.29370>; else goto <D.29371>;
      <D.29370>:
      <D.29371>:
      D.29224 = cfg;
      return D.29224;
      <D.29369>:
      mono_destroy_compile (cfg);
      try_generic_shared = 0;
      goto restart_compile;
      <D.29367>:
      <D.29364>:
      D.29365 = cfg->exception_type;
      D.29372 = D.29365 == 11;
      D.29373 = (long int) D.29372;
      D.29374 = __builtin_expect (D.29373, 0);
      if (D.29374 != 0) goto <D.29375>; else goto <D.29376>;
      <D.29375>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5206, "cfg->exception_type != MONO_EXCEPTION_GENERIC_SHARING_FAILED");
      <D.29376>:
      if (0 != 0) goto <D.29377>; else goto <D.29378>;
      <D.29377>:
      <D.29378>:
      D.29224 = cfg;
      return D.29224;
      <D.29362>:
      D.29379 = cfg->stat_basic_blocks;
      D.29380 = (unsigned int) D.29379;
      D.29381 = cfg->num_bblocks;
      D.29382 = D.29380 + D.29381;
      D.29383 = (int) D.29382;
      cfg->stat_basic_blocks = D.29383;
      if (0 != 0) goto <D.29384>; else goto <D.29385>;
      <D.29384>:
      {
        struct MonoInst * ins;

        D.29278 = cfg->opt;
        D.29325 = D.29278 | 2097152;
        cfg->opt = D.29325;
        D.29386 = cfg->ret;
        if (D.29386 != 0B) goto <D.29387>; else goto <D.29388>;
        <D.29387>:
        D.29386 = cfg->ret;
        D.29386 = cfg->ret;
        D.29389 = D.29386->flags;
        D.29390 = D.29389 & 251;
        D.29386->flags = D.29390;
        D.29307 = cfg->mempool;
        ins = mono_mempool_alloc (D.29307, 48);
        ins->data.op[1].const_val = 0;
        D.29391 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.29391;
        ins->prev = 0B;
        D.29392 = ins->prev;
        ins->next = D.29392;
        ins->opcode = 335;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.29393 = ins->sreg3;
        ins->sreg2 = D.29393;
        D.29394 = ins->sreg2;
        ins->sreg1 = D.29394;
        D.29395 = cfg->ip;
        ins->cil_code = D.29395;
        D.29386 = cfg->ret;
        D.29396 = D.29386->dreg;
        ins->sreg1 = D.29396;
        D.29397 = cfg->bb_exit;
        D.29398 = D.29397->last_ins;
        if (D.29398 != 0B) goto <D.29399>; else goto <D.29400>;
        <D.29399>:
        D.29397 = cfg->bb_exit;
        D.29398 = D.29397->last_ins;
        D.29398->next = ins;
        D.29397 = cfg->bb_exit;
        D.29398 = D.29397->last_ins;
        ins->prev = D.29398;
        D.29397 = cfg->bb_exit;
        D.29397->last_ins = ins;
        goto <D.29401>;
        <D.29400>:
        D.29397 = cfg->bb_exit;
        D.29397 = cfg->bb_exit;
        D.29397->last_ins = ins;
        D.29398 = D.29397->last_ins;
        D.29397->code = D.29398;
        <D.29401>:
        <D.29388>:
        D.29278 = cfg->opt;
        D.29402 = D.29278 & 4294967167;
        cfg->opt = D.29402;
        D.29278 = cfg->opt;
        D.29403 = D.29278 & 4294967293;
        cfg->opt = D.29403;
      }
      <D.29385>:
      mono_liveness_handle_exception_clauses (cfg);
      mono_handle_out_of_line_bblock (cfg);
      if (1 != 0) goto <D.29404>; else goto <D.29405>;
      <D.29404>:
      mono_decompose_long_opts (cfg);
      <D.29405>:
      D.29278 = cfg->opt;
      D.29406 = D.29278 & 48;
      if (D.29406 != 0) goto <D.29407>; else goto <D.29408>;
      <D.29407>:
      mono_local_cprop (cfg);
      <D.29408>:
      D.29278 = cfg->opt;
      D.29409 = D.29278 & 2;
      if (D.29409 != 0) goto <D.29410>; else goto <D.29411>;
      <D.29410>:
      mono_optimize_branches (cfg);
      <D.29411>:
      mono_handle_global_vregs (cfg);
      D.29278 = cfg->opt;
      D.29412 = D.29278 & 64;
      if (D.29412 != 0) goto <D.29413>; else goto <D.29414>;
      <D.29413>:
      mono_local_deadce (cfg);
      <D.29414>:
      D.29278 = cfg->opt;
      D.29415 = D.29278 & 268435456;
      if (D.29415 != 0) goto <D.29416>; else goto <D.29417>;
      <D.29416>:
      mono_local_alias_analysis (cfg);
      <D.29417>:
      if (1 != 0) goto <D.29418>; else goto <D.29419>;
      <D.29418>:
      mono_if_conversion (cfg);
      <D.29419>:
      D.29278 = cfg->opt;
      D.29422 = D.29278 & 524288;
      if (D.29422 != 0) goto <D.29420>; else goto <D.29423>;
      <D.29423>:
      D.29343 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.29344 = D.29343 & 16;
      if (D.29344 != 0) goto <D.29420>; else goto <D.29421>;
      <D.29420>:
      mono_remove_critical_edges (cfg);
      <D.29421>:
      D.29381 = cfg->num_bblocks;
      D.29424 = D.29381 + 1;
      D.29425 = D.29424 * 4;
      D.29307 = cfg->mempool;
      D.29426 = mono_mempool_alloc (D.29307, D.29425);
      cfg->bblocks = D.29426;
      D.29381 = cfg->num_bblocks;
      cfg->max_block_num = D.29381;
      dfn = 0;
      D.29427 = cfg->bblocks;
      D.29428 = cfg->bb_entry;
      df_visit (D.29428, &dfn, D.29427);
      D.29381 = cfg->num_bblocks;
      dfn.122 = dfn;
      D.29430 = dfn.122 + 1;
      D.29431 = (unsigned int) D.29430;
      if (D.29381 != D.29431) goto <D.29432>; else goto <D.29433>;
      <D.29432>:
      {
        struct MonoBasicBlock * bb;

        dfn.122 = dfn;
        D.29430 = dfn.122 + 1;
        D.29431 = (unsigned int) D.29430;
        cfg->num_bblocks = D.29431;
        bb = cfg->bb_entry;
        goto <D.26030>;
        <D.26029>:
        D.29434 = bb->flags;
        D.29435 = D.29434 & 4294967294;
        bb->flags = D.29435;
        bb = bb->next_bb;
        <D.26030>:
        if (bb != 0B) goto <D.26029>; else goto <D.26031>;
        <D.26031>:
        D.29428 = cfg->bb_entry;
        compute_reachable (D.29428);
        bb = cfg->bb_entry;
        goto <D.26033>;
        <D.26032>:
        D.29434 = bb->flags;
        D.29436 = D.29434 & 16;
        if (D.29436 != 0) goto <D.29437>; else goto <D.29438>;
        <D.29437>:
        compute_reachable (bb);
        <D.29438>:
        bb = bb->next_bb;
        <D.26033>:
        if (bb != 0B) goto <D.26032>; else goto <D.26034>;
        <D.26034>:
        bb = cfg->bb_entry;
        goto <D.26039>;
        <D.26038>:
        D.29434 = bb->flags;
        D.29439 = D.29434 & 1;
        if (D.29439 == 0) goto <D.29440>; else goto <D.29441>;
        <D.29440>:
        D.29309 = cfg->verbose_level;
        if (D.29309 > 1) goto <D.29442>; else goto <D.29443>;
        <D.29442>:
        D.29444 = bb->block_num;
        monoeg_g_print ("found unreachable code in BB%d\n", D.29444);
        <D.29443>:
        bb->last_ins = 0B;
        D.29445 = bb->last_ins;
        bb->code = D.29445;
        goto <D.26036>;
        <D.26035>:
        D.29446 = bb->out_bb;
        D.29447 = *D.29446;
        mono_unlink_bblock (cfg, bb, D.29447);
        <D.26036>:
        D.29448 = bb->out_count;
        if (D.29448 != 0) goto <D.26035>; else goto <D.26037>;
        <D.26037>:
        <D.29441>:
        bb = bb->next_bb;
        <D.26039>:
        if (bb != 0B) goto <D.26038>; else goto <D.26040>;
        <D.26040>:
        bb = cfg->bb_entry;
        goto <D.26042>;
        <D.26041>:
        D.29434 = bb->flags;
        D.29435 = D.29434 & 4294967294;
        bb->flags = D.29435;
        bb = bb->next_bb;
        <D.26042>:
        if (bb != 0B) goto <D.26041>; else goto <D.26043>;
        <D.26043>:
      }
      <D.29433>:
      D.29451 = cfg->num_varinfo;
      if (D.29451 > 2000) goto <D.29449>; else goto <D.29452>;
      <D.29452>:
      D.29381 = cfg->num_bblocks;
      if (D.29381 > 1000) goto <D.29449>; else goto <D.29450>;
      <D.29449>:
      D.29216 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.29217 = D.29216 & 64;
      if (D.29217 == 0) goto <D.29453>; else goto <D.29454>;
      <D.29453>:
      D.29278 = cfg->opt;
      D.29455 = D.29278 & 4294967119;
      cfg->opt = D.29455;
      cfg->disable_ssa = 1;
      <D.29454>:
      <D.29450>:
      D.29278 = cfg->opt;
      D.29456 = D.29278 & 8192;
      if (D.29456 != 0) goto <D.29457>; else goto <D.29458>;
      <D.29457>:
      mono_compile_dominator_info (cfg, 3);
      mono_compute_natural_loops (cfg);
      <D.29458>:
      if (parts == 1) goto <D.29459>; else goto <D.29460>;
      <D.29459>:
      if (0 != 0) goto <D.29461>; else goto <D.29462>;
      <D.29461>:
      <D.29462>:
      D.29224 = cfg;
      return D.29224;
      <D.29460>:
      D.29278 = cfg->opt;
      D.29350 = D.29278 & 2097152;
      if (D.29350 != 0) goto <D.29463>; else goto <D.29464>;
      <D.29463>:
      D.29465 = cfg->comp_done;
      D.29466 = D.29465 & 32;
      if (D.29466 == 0) goto <D.29467>; else goto <D.29468>;
      <D.29467>:
      D.29216 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.29469 = D.29216 & 2;
      if (D.29469 == 0) goto <D.29470>; else goto <D.29471>;
      <D.29470>:
      mono_ssa_compute (cfg);
      D.29309 = cfg->verbose_level;
      if (D.29309 > 1) goto <D.29472>; else goto <D.29473>;
      <D.29472>:
      print_dfn (cfg);
      <D.29473>:
      <D.29471>:
      <D.29468>:
      <D.29464>:
      if (parts == 2) goto <D.29474>; else goto <D.29475>;
      <D.29474>:
      if (0 != 0) goto <D.29476>; else goto <D.29477>;
      <D.29476>:
      <D.29477>:
      D.29224 = cfg;
      return D.29224;
      <D.29475>:
      D.29478 = BIT_FIELD_REF <*cfg, 32, 3104>;
      D.29479 = D.29478 & 48;
      if (D.29479 != 0) goto <D.29480>; else goto <D.29481>;
      <D.29480>:
      D.29465 = cfg->comp_done;
      D.29466 = D.29465 & 32;
      if (D.29466 != 0) goto <D.29482>; else goto <D.29483>;
      <D.29482>:
      mono_ssa_cprop (cfg);
      <D.29483>:
      <D.29481>:
      D.29465 = cfg->comp_done;
      D.29466 = D.29465 & 32;
      if (D.29466 != 0) goto <D.29484>; else goto <D.29485>;
      <D.29484>:
      D.29278 = cfg->opt;
      D.29422 = D.29278 & 524288;
      if (D.29422 != 0) goto <D.29486>; else goto <D.29487>;
      <D.29486>:
      mono_perform_ssapre (cfg);
      <D.29487>:
      D.29278 = cfg->opt;
      D.29412 = D.29278 & 64;
      if (D.29412 != 0) goto <D.29488>; else goto <D.29489>;
      <D.29488>:
      mono_ssa_deadce (cfg);
      deadce_has_run = 1;
      <D.29489>:
      D.29490 = cfg->flags;
      D.29491 = D.29490 & 132;
      if (D.29491 != 0) goto <D.29492>; else goto <D.29493>;
      <D.29492>:
      D.29278 = cfg->opt;
      D.29494 = D.29278 & 262144;
      if (D.29494 != 0) goto <D.29495>; else goto <D.29496>;
      <D.29495>:
      mono_perform_abc_removal (cfg);
      <D.29496>:
      <D.29493>:
      mono_ssa_remove (cfg);
      mono_local_cprop (cfg);
      mono_handle_global_vregs (cfg);
      D.29278 = cfg->opt;
      D.29412 = D.29278 & 64;
      if (D.29412 != 0) goto <D.29497>; else goto <D.29498>;
      <D.29497>:
      mono_local_deadce (cfg);
      <D.29498>:
      D.29278 = cfg->opt;
      D.29409 = D.29278 & 2;
      if (D.29409 != 0) goto <D.29499>; else goto <D.29500>;
      <D.29499>:
      {
        struct MonoBasicBlock * bb;

        mono_optimize_branches (cfg);
        D.29343 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.29344 = D.29343 & 16;
        if (D.29344 != 0) goto <D.29501>; else goto <D.29502>;
        <D.29501>:
        mono_remove_critical_edges (cfg);
        bb = cfg->bb_entry;
        goto <D.26046>;
        <D.26045>:
        bb->dfn = 0;
        bb = bb->next_bb;
        <D.26046>:
        if (bb != 0B) goto <D.26045>; else goto <D.26047>;
        <D.26047>:
        D.29381 = cfg->num_bblocks;
        D.29424 = D.29381 + 1;
        D.29425 = D.29424 * 4;
        D.29307 = cfg->mempool;
        D.29503 = mono_mempool_alloc (D.29307, D.29425);
        cfg->bblocks = D.29503;
        dfn = 0;
        D.29427 = cfg->bblocks;
        D.29428 = cfg->bb_entry;
        df_visit (D.29428, &dfn, D.29427);
        dfn.122 = dfn;
        D.29430 = dfn.122 + 1;
        D.29431 = (unsigned int) D.29430;
        cfg->num_bblocks = D.29431;
        <D.29502>:
      }
      <D.29500>:
      <D.29485>:
      if (0 != 0) goto <D.29504>; else goto <D.29505>;
      <D.29504>:
      mono_ssa_loop_invariant_code_motion (cfg);
      D.29278 = cfg->opt;
      D.29494 = D.29278 & 262144;
      if (D.29494 != 0) goto <D.29506>; else goto <D.29507>;
      <D.29506>:
      mono_perform_abc_removal (cfg);
      <D.29507>:
      <D.29505>:
      if (parts == 3) goto <D.29508>; else goto <D.29509>;
      <D.29508>:
      if (0 != 0) goto <D.29510>; else goto <D.29511>;
      <D.29510>:
      <D.29511>:
      D.29224 = cfg;
      return D.29224;
      <D.29509>:
      if (0 != 0) goto <D.29512>; else goto <D.29513>;
      <D.29512>:
      mono_decompose_vtype_opts_llvm (cfg);
      goto <D.29514>;
      <D.29513>:
      mono_decompose_vtype_opts (cfg);
      <D.29514>:
      D.29490 = cfg->flags;
      D.29515 = D.29490 & 256;
      if (D.29515 != 0) goto <D.29516>; else goto <D.29517>;
      <D.29516>:
      mono_decompose_array_access_opts (cfg);
      <D.29517>:
      D.29518 = cfg->got_var;
      if (D.29518 != 0B) goto <D.29519>; else goto <D.29520>;
      <D.29519>:
      {
        int got_reg;

        D.29343 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.29521 = D.29343 & 2;
        D.29522 = D.29521 == 0;
        D.29523 = (long int) D.29522;
        D.29524 = __builtin_expect (D.29523, 0);
        if (D.29524 != 0) goto <D.29525>; else goto <D.29526>;
        <D.29525>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5460, "cfg->got_var_allocated");
        <D.29526>:
        got_reg = 3;
        D.29518 = cfg->got_var;
        D.29518->opcode = 366;
        D.29518 = cfg->got_var;
        D.29518->dreg = got_reg;
        D.29527 = cfg->used_int_regs;
        D.29528 = (signed int) D.29527;
        D.29518 = cfg->got_var;
        D.29529 = D.29518->dreg;
        D.29530 = 1 << D.29529;
        D.29531 = (signed int) D.29530;
        D.29532 = D.29528 | D.29531;
        D.29533 = (unsigned int) D.29532;
        cfg->used_int_regs = D.29533;
      }
      <D.29520>:
      mono_liveness_handle_exception_clauses (cfg);
      D.29343 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.29344 = D.29343 & 16;
      if (D.29344 != 0) goto <D.29534>; else goto <D.29535>;
      <D.29534>:
      {
        struct MonoBasicBlock * bb;

        bb = cfg->bb_entry;
        goto <D.26051>;
        <D.26050>:
        mono_arch_lowering_pass (cfg, bb);
        bb = bb->next_bb;
        <D.26051>:
        if (bb != 0B) goto <D.26050>; else goto <D.26052>;
        <D.26052>:
        mono_global_regalloc (cfg);
      }
      <D.29535>:
      D.29278 = cfg->opt;
      D.29536 = D.29278 & 128;
      if (D.29536 != 0) goto <D.29537>; else goto <D.29538>;
      <D.29537>:
      D.29343 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.29344 = D.29343 & 16;
      if (D.29344 == 0) goto <D.29539>; else goto <D.29540>;
      <D.29539>:
      {
        struct GList * vars;
        struct GList * regs;
        struct GList * l;

        D.29465 = cfg->comp_done;
        D.29541 = D.29465 & 4294967279;
        cfg->comp_done = D.29541;
        D.29465 = cfg->comp_done;
        D.29542 = D.29465 & 16;
        if (D.29542 == 0) goto <D.29543>; else goto <D.29544>;
        <D.29543>:
        mono_analyze_liveness (cfg);
        <D.29544>:
        vars = mono_arch_get_allocatable_int_vars (cfg);
        if (vars != 0B) goto <D.29545>; else goto <D.29546>;
        <D.29545>:
        regs = mono_arch_get_global_int_regs (cfg);
        D.29518 = cfg->got_var;
        if (D.29518 != 0B) goto <D.29547>; else goto <D.29548>;
        <D.29547>:
        l = regs;
        goto <D.26058>;
        <D.26057>:
        D.29549 = l->data;
        D.29550 = (unsigned int) D.29549;
        D.29518 = cfg->got_var;
        D.29529 = D.29518->dreg;
        D.29551 = (unsigned int) D.29529;
        if (D.29550 == D.29551) goto <D.29552>; else goto <D.29553>;
        <D.29552>:
        regs = monoeg_g_list_delete_link (regs, l);
        goto <D.26056>;
        <D.29553>:
        l = l->next;
        <D.26058>:
        if (l != 0B) goto <D.26057>; else goto <D.26056>;
        <D.26056>:
        <D.29548>:
        D.29554 = &cfg->used_int_regs;
        mono_linear_scan (cfg, vars, regs, D.29554);
        <D.29546>:
      }
      <D.29540>:
      <D.29538>:
      D.29343 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.29344 = D.29343 & 16;
      if (D.29344 == 0) goto <D.29555>; else goto <D.29556>;
      <D.29555>:
      mono_arch_allocate_vars (cfg);
      D.29365 = cfg->exception_type;
      if (D.29365 != 0) goto <D.29557>; else goto <D.29558>;
      <D.29557>:
      D.29224 = cfg;
      return D.29224;
      <D.29558>:
      <D.29556>:
      {
        struct MonoBasicBlock * bb;
        gboolean need_local_opts;

        try
          {
            D.29343 = BIT_FIELD_REF <*cfg, 8, 3400>;
            D.29344 = D.29343 & 16;
            if (D.29344 == 0) goto <D.29559>; else goto <D.29560>;
            <D.29559>:
            mono_spill_global_vars (cfg, &need_local_opts);
            need_local_opts.123 = need_local_opts;
            if (need_local_opts.123 != 0) goto <D.29561>; else goto <D.29564>;
            <D.29564>:
            D.29216 = BIT_FIELD_REF <*cfg, 8, 3392>;
            D.29217 = D.29216 & 64;
            if (D.29217 != 0) goto <D.29561>; else goto <D.29562>;
            <D.29561>:
            mono_local_cprop (cfg);
            D.29278 = cfg->opt;
            D.29412 = D.29278 & 64;
            if (D.29412 != 0) goto <D.29565>; else goto <D.29566>;
            <D.29565>:
            mono_local_deadce (cfg);
            <D.29566>:
            <D.29562>:
            <D.29560>:
            bb = cfg->bb_entry;
            goto <D.26064>;
            <D.26063>:
            D.29569 = bb->last_ins;
            if (D.29569 != 0B) goto <D.29570>; else goto <D.29571>;
            <D.29570>:
            D.29569 = bb->last_ins;
            D.29572 = D.29569->opcode;
            D.29573 = D.29572 + 64981;
            D.29574 = D.29573 <= 9;
            D.29575 = D.29572 + 64874;
            D.29576 = D.29575 <= 9;
            D.29577 = D.29574 | D.29576;
            if (D.29577 != 0) goto <D.29567>; else goto <D.29578>;
            <D.29578>:
            D.29569 = bb->last_ins;
            D.29579 = D.29569->opcode;
            D.29580 = D.29579 + 64884;
            if (D.29580 <= 9) goto <D.29567>; else goto <D.29568>;
            <D.29567>:
            D.29569 = bb->last_ins;
            D.29581 = D.29569->data.op[1].many_blocks;
            D.29582 = D.29581 + 4;
            D.29583 = *D.29582;
            if (D.29583 != 0B) goto <D.29584>; else goto <D.29585>;
            <D.29584>:
            D.29586 = bb->next_bb;
            D.29569 = bb->last_ins;
            D.29581 = D.29569->data.op[1].many_blocks;
            D.29582 = D.29581 + 4;
            D.29583 = *D.29582;
            if (D.29586 != D.29583) goto <D.29587>; else goto <D.29588>;
            <D.29587>:
            D.29569 = bb->last_ins;
            D.29593 = D.29569->opcode;
            D.29594 = D.29593 + 64981;
            D.29595 = D.29594 <= 9;
            D.29596 = D.29593 + 64874;
            D.29597 = D.29596 <= 9;
            D.29598 = D.29595 | D.29597;
            if (D.29598 != 0) goto <D.29589>; else goto <D.29599>;
            <D.29599>:
            D.29569 = bb->last_ins;
            D.29579 = D.29569->opcode;
            D.29580 = D.29579 + 64884;
            if (D.29580 <= 9) goto <D.29589>; else goto <D.29590>;
            <D.29589>:
            D.29569 = bb->last_ins;
            D.29579 = D.29569->opcode;
            D.29600 = D.29579 + 64874;
            if (D.29600 > 9) goto <D.29601>; else goto <D.29590>;
            <D.29601>:
            D.29569 = bb->last_ins;
            D.29602 = D.29569->data.op[0].src;
            if (D.29602 == 0B) goto <D.29591>; else goto <D.29603>;
            <D.29603>:
            D.29569 = bb->last_ins;
            D.29602 = D.29569->data.op[0].src;
            D.29604 = D.29602->data.op[0].src;
            D.29605 = D.29604->type;
            if (D.29605 != 4) goto <D.29591>; else goto <D.29590>;
            <D.29591>:
            D.29586 = bb->next_bb;
            D.29569 = bb->last_ins;
            D.29581 = D.29569->data.op[1].many_blocks;
            D.29606 = *D.29581;
            if (D.29586 == D.29606) goto <D.29607>; else goto <D.29590>;
            <D.29607>:
            {
              struct MonoBasicBlock * tmp;

              D.29569 = bb->last_ins;
              D.29581 = D.29569->data.op[1].many_blocks;
              tmp = *D.29581;
              D.29569 = bb->last_ins;
              D.29581 = D.29569->data.op[1].many_blocks;
              D.29569 = bb->last_ins;
              D.29581 = D.29569->data.op[1].many_blocks;
              D.29608 = MEM[(struct MonoBasicBlock * *)D.29581 + 4B];
              *D.29581 = D.29608;
              D.29569 = bb->last_ins;
              D.29581 = D.29569->data.op[1].many_blocks;
              D.29582 = D.29581 + 4;
              *D.29582 = tmp;
              D.29569 = bb->last_ins;
              D.29569 = bb->last_ins;
              D.29579 = D.29569->opcode;
              D.29609 = (unsigned int) D.29579;
              D.29610 = mono_reverse_branch_op (D.29609);
              D.29611 = (short unsigned int) D.29610;
              D.29569->opcode = D.29611;
            }
            goto <D.29592>;
            <D.29590>:
            {
              struct MonoInst * inst;

              D.29307 = cfg->mempool;
              inst = mono_mempool_alloc0 (D.29307, 48);
              inst->opcode = 446;
              D.29569 = bb->last_ins;
              D.29581 = D.29569->data.op[1].many_blocks;
              D.29608 = MEM[(struct MonoBasicBlock * *)D.29581 + 4B];
              inst->data.op[0].target_block = D.29608;
              mono_bblock_add_inst (bb, inst);
            }
            <D.29592>:
            <D.29588>:
            <D.29585>:
            <D.29568>:
            <D.29571>:
            bb = bb->next_bb;
            <D.26064>:
            if (bb != 0B) goto <D.26063>; else goto <D.26065>;
            <D.26065>:
            D.29309 = cfg->verbose_level;
            if (D.29309 > 3) goto <D.29612>; else goto <D.29613>;
            <D.29612>:
            D.29343 = BIT_FIELD_REF <*cfg, 8, 3400>;
            D.29344 = D.29343 & 16;
            if (D.29344 == 0) goto <D.29614>; else goto <D.29615>;
            <D.29614>:
            bb = cfg->bb_entry;
            goto <D.26072>;
            <D.26071>:
            {
              struct MonoInst * tree;

              tree = bb->code;
              D.29616 = bb->block_num;
              monoeg_g_print ("DUMP BLOCK %d:\n", D.29616);
              if (tree == 0B) goto <D.29617>; else goto <D.29618>;
              <D.29617>:
              // predicted unlikely by continue predictor.
              goto <D.26067>;
              <D.29618>:
              goto <D.26069>;
              <D.26068>:
              mono_print_ins_index (-1, tree);
              tree = tree->next;
              <D.26069>:
              if (tree != 0B) goto <D.26068>; else goto <D.26070>;
              <D.26070>:
            }
            <D.26067>:
            bb = bb->next_bb;
            <D.26072>:
            if (bb != 0B) goto <D.26071>; else goto <D.26073>;
            <D.26073>:
            <D.29615>:
            <D.29613>:
            bb = cfg->bb_entry;
            goto <D.26075>;
            <D.26074>:
            D.29619 = cfg->next_vreg;
            bb->max_vreg = D.29619;
            bb = bb->next_bb;
            <D.26075>:
            if (bb != 0B) goto <D.26074>; else goto <D.26076>;
            <D.26076>:
          }
        finally
          {
            need_local_opts = {CLOBBER};
          }
      }
      if (0 != 0) goto <D.29620>; else goto <D.29621>;
      <D.29620>:
      goto <D.29622>;
      <D.29621>:
      mono_codegen (cfg);
      <D.29622>:
      if (0 != 0) goto <D.29623>; else goto <D.29624>;
      <D.29623>:
      InterlockedIncrement (&mono_jit_stats.methods_with_llvm);
      goto <D.29625>;
      <D.29624>:
      InterlockedIncrement (&mono_jit_stats.methods_without_llvm);
      <D.29625>:
      D.29626 = create_jit_info (cfg, method_to_compile);
      cfg->jit_info = D.29626;
      D.29627 = BIT_FIELD_REF <*cfg, 8, 3416>;
      D.29628 = D.29627 & 64;
      if (D.29628 != 0) goto <D.29629>; else goto <D.29630>;
      <D.29629>:
      i = 0;
      goto <D.26078>;
      <D.26077>:
      D.29631 = cfg->vars;
      i.124 = (unsigned int) i;
      D.29633 = i.124 * 56;
      D.29634 = D.29631 + D.29633;
      D.29635 = cfg->code_len;
      D.29636 = (int) D.29635;
      D.29634->live_range_end = D.29636;
      i = i + 1;
      <D.26078>:
      i.125 = (unsigned int) i;
      D.29451 = cfg->num_varinfo;
      if (i.125 < D.29451) goto <D.26077>; else goto <D.26079>;
      <D.26079>:
      <D.29630>:
      D.29216 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.29217 = D.29216 & 64;
      if (D.29217 == 0) goto <D.29638>; else goto <D.29639>;
      <D.29638>:
      mono_save_xdebug_info (cfg);
      <D.29639>:
      mini_gc_create_gc_map (cfg);
      mono_save_seq_point_info (cfg);
      D.29309 = cfg->verbose_level;
      if (D.29309 > 1) goto <D.29640>; else goto <D.29641>;
      <D.29640>:
      {
        char * id;

        D.29181 = cfg->method;
        id = mono_method_full_name (D.29181, 0);
        D.29642 = id + 3;
        D.29635 = cfg->code_len;
        D.29643 = (int) D.29635;
        D.29644 = cfg->native_code;
        mono_disassemble_code (cfg, D.29644, D.29643, D.29642);
        monoeg_g_free (id);
      }
      <D.29641>:
      D.29216 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.29217 = D.29216 & 64;
      if (D.29217 == 0) goto <D.29645>; else goto <D.29646>;
      <D.29645>:
      {
        int ret;

        D.29647 = cfg->domain;
        D.29648 = &D.29647->lock.mutex;
        ret = pthread_mutex_lock (D.29648);
        if (ret != 0) goto <D.29649>; else goto <D.29650>;
        <D.29649>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29650>:
        D.29651 = ret != 0;
        D.29652 = (long int) D.29651;
        D.29653 = __builtin_expect (D.29652, 0);
        if (D.29653 != 0) goto <D.29654>; else goto <D.29655>;
        <D.29654>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5653, "ret == 0");
        <D.29655>:
      }
      D.29656 = cfg->jit_info;
      D.29647 = cfg->domain;
      mono_jit_info_table_add (D.29647, D.29656);
      D.29181 = cfg->method;
      D.29335 = BIT_FIELD_REF <*D.29181, 8, 168>;
      D.29657 = D.29335 & 2;
      if (D.29657 != 0) goto <D.29658>; else goto <D.29659>;
      <D.29658>:
      D.29181 = cfg->method;
      D.29647 = cfg->domain;
      D.29660 = mono_dynamic_code_hash_lookup (D.29647, D.29181);
      D.29656 = cfg->jit_info;
      D.29660->ji = D.29656;
      <D.29659>:
      {
        int ret;

        D.29647 = cfg->domain;
        D.29648 = &D.29647->lock.mutex;
        ret = pthread_mutex_unlock (D.29648);
        if (ret != 0) goto <D.29661>; else goto <D.29662>;
        <D.29661>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29662>:
        D.29663 = ret != 0;
        D.29664 = (long int) D.29663;
        D.29665 = __builtin_expect (D.29664, 0);
        if (D.29665 != 0) goto <D.29666>; else goto <D.29667>;
        <D.29666>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5658, "ret == 0");
        <D.29667>:
      }
      <D.29646>:
      mono_perfcounters.126 = mono_perfcounters;
      D.29669 = mono_perfcounters.126->jit_methods;
      D.29670 = D.29669 + 1;
      mono_perfcounters.126->jit_methods = D.29670;
      mono_perfcounters.126 = mono_perfcounters;
      mono_perfcounters.126 = mono_perfcounters;
      D.29671 = mono_perfcounters.126->jit_bytes;
      D.29339 = header->code_size;
      D.29672 = D.29671 + D.29339;
      mono_perfcounters.126->jit_bytes = D.29672;
      D.29673 = mono_jit_stats.allocated_code_size;
      D.29674 = (unsigned int) D.29673;
      D.29635 = cfg->code_len;
      D.29675 = D.29674 + D.29635;
      D.29676 = (int) D.29675;
      mono_jit_stats.allocated_code_size = D.29676;
      D.29635 = cfg->code_len;
      code_size_ratio = (int) D.29635;
      D.29677 = mono_jit_stats.biggest_method_size;
      if (D.29677 < code_size_ratio) goto <D.29678>; else goto <D.29679>;
      <D.29678>:
      D.29680 = mono_jit_stats.enabled;
      if (D.29680 != 0) goto <D.29681>; else goto <D.29682>;
      <D.29681>:
      mono_jit_stats.biggest_method_size = code_size_ratio;
      D.29683 = mono_jit_stats.biggest_method;
      monoeg_g_free (D.29683);
      D.29684 = method->name;
      D.29117 = method->klass;
      D.29685 = D.29117->name;
      D.29686 = monoeg_g_strdup_printf ("%s::%s)", D.29685, D.29684);
      mono_jit_stats.biggest_method = D.29686;
      <D.29682>:
      <D.29679>:
      D.29687 = code_size_ratio * 100;
      D.29688 = (unsigned int) D.29687;
      D.29339 = header->code_size;
      D.29689 = D.29688 / D.29339;
      code_size_ratio = (int) D.29689;
      D.29690 = mono_jit_stats.max_code_size_ratio;
      if (D.29690 < code_size_ratio) goto <D.29691>; else goto <D.29692>;
      <D.29691>:
      D.29680 = mono_jit_stats.enabled;
      if (D.29680 != 0) goto <D.29693>; else goto <D.29694>;
      <D.29693>:
      mono_jit_stats.max_code_size_ratio = code_size_ratio;
      D.29695 = mono_jit_stats.max_ratio_method;
      monoeg_g_free (D.29695);
      D.29684 = method->name;
      D.29117 = method->klass;
      D.29685 = D.29117->name;
      D.29696 = monoeg_g_strdup_printf ("%s::%s)", D.29685, D.29684);
      mono_jit_stats.max_ratio_method = D.29696;
      <D.29694>:
      <D.29692>:
      D.29697 = mono_jit_stats.native_code_size;
      D.29698 = (unsigned int) D.29697;
      D.29635 = cfg->code_len;
      D.29699 = D.29698 + D.29635;
      D.29700 = (int) D.29699;
      mono_jit_stats.native_code_size = D.29700;
      if (0 != 0) goto <D.29701>; else goto <D.29702>;
      <D.29701>:
      <D.29702>:
      D.29224 = cfg;
      return D.29224;
    }
  finally
    {
      err = {CLOBBER};
      dfn = {CLOBBER};
    }
}


is_gsharedvt_method (struct MonoMethod * method)
{
  unsigned char D.29705;
  unsigned char D.29706;
  gboolean D.29709;
  struct MonoType * D.29712;
  int D.29713;
  <unnamed-unsigned:22> D.29716;
  int D.29717;
  int D.29720;
  struct MonoGenericContext * context;
  struct MonoGenericInst * inst;
  int i;

  D.29705 = BIT_FIELD_REF <*method, 8, 168>;
  D.29706 = D.29705 & 16;
  if (D.29706 == 0) goto <D.29707>; else goto <D.29708>;
  <D.29707>:
  D.29709 = 0;
  return D.29709;
  <D.29708>:
  context = mono_method_get_context (method);
  inst = context->class_inst;
  if (inst != 0B) goto <D.29710>; else goto <D.29711>;
  <D.29710>:
  i = 0;
  goto <D.25933>;
  <D.25932>:
  D.29712 = inst->type_argv[i];
  D.29713 = is_gsharedvt_type (D.29712);
  if (D.29713 != 0) goto <D.29714>; else goto <D.29715>;
  <D.29714>:
  D.29709 = 1;
  return D.29709;
  <D.29715>:
  i = i + 1;
  <D.25933>:
  D.29716 = inst->type_argc;
  D.29717 = (int) D.29716;
  if (D.29717 > i) goto <D.25932>; else goto <D.25934>;
  <D.25934>:
  <D.29711>:
  inst = context->method_inst;
  if (inst != 0B) goto <D.29718>; else goto <D.29719>;
  <D.29718>:
  i = 0;
  goto <D.25936>;
  <D.25935>:
  D.29712 = inst->type_argv[i];
  D.29720 = is_gsharedvt_type (D.29712);
  if (D.29720 != 0) goto <D.29721>; else goto <D.29722>;
  <D.29721>:
  D.29709 = 1;
  return D.29709;
  <D.29722>:
  i = i + 1;
  <D.25936>:
  D.29716 = inst->type_argc;
  D.29717 = (int) D.29716;
  if (D.29717 > i) goto <D.25935>; else goto <D.25937>;
  <D.25937>:
  <D.29719>:
  D.29709 = 0;
  return D.29709;
}


is_gsharedvt_type (struct MonoType * t)
{
  gboolean D.29724;
  int iftmp.127;
  unsigned char D.29728;
  _Bool D.29729;
  _Bool D.29730;
  _Bool D.29731;
  struct MonoGenericParam * D.29733;
  short unsigned int D.29734;

  D.29728 = t->type;
  D.29729 = D.29728 == 19;
  D.29730 = D.29728 == 30;
  D.29731 = D.29729 | D.29730;
  if (D.29731 != 0) goto <D.29732>; else goto <D.29726>;
  <D.29732>:
  D.29733 = t->data.generic_param;
  D.29734 = D.29733->serial;
  if (D.29734 == 1) goto <D.29735>; else goto <D.29726>;
  <D.29735>:
  iftmp.127 = 1;
  goto <D.29727>;
  <D.29726>:
  iftmp.127 = 0;
  <D.29727>:
  D.29724 = iftmp.127;
  return D.29724;
}


is_open_method (struct MonoMethod * method)
{
  unsigned char D.29737;
  unsigned char D.29738;
  gboolean D.29741;
  struct MonoGenericInst * D.29742;
  unsigned char D.29745;
  unsigned char D.29746;
  struct MonoGenericInst * D.29749;
  unsigned char D.29752;
  unsigned char D.29753;
  struct MonoGenericContext * context;

  D.29737 = BIT_FIELD_REF <*method, 8, 168>;
  D.29738 = D.29737 & 16;
  if (D.29738 == 0) goto <D.29739>; else goto <D.29740>;
  <D.29739>:
  D.29741 = 0;
  return D.29741;
  <D.29740>:
  context = mono_method_get_context (method);
  D.29742 = context->class_inst;
  if (D.29742 != 0B) goto <D.29743>; else goto <D.29744>;
  <D.29743>:
  D.29742 = context->class_inst;
  D.29745 = BIT_FIELD_REF <*D.29742, 8, 48>;
  D.29746 = D.29745 & 64;
  if (D.29746 != 0) goto <D.29747>; else goto <D.29748>;
  <D.29747>:
  D.29741 = 1;
  return D.29741;
  <D.29748>:
  <D.29744>:
  D.29749 = context->method_inst;
  if (D.29749 != 0B) goto <D.29750>; else goto <D.29751>;
  <D.29750>:
  D.29749 = context->method_inst;
  D.29752 = BIT_FIELD_REF <*D.29749, 8, 48>;
  D.29753 = D.29752 & 64;
  if (D.29753 != 0) goto <D.29754>; else goto <D.29755>;
  <D.29754>:
  D.29741 = 1;
  return D.29741;
  <D.29755>:
  <D.29751>:
  D.29741 = 0;
  return D.29741;
}


mono_compile_create_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.29757;
  struct MonoType * D.29758;
  int D.29759;
  struct MonoInst * D.29762;
  struct MonoInst * D.29763;
  unsigned char D.29764;
  unsigned char D.29765;
  unsigned int D.29766;
  short unsigned int D.29769;
  int D.29770;
  <unnamed-unsigned:1> D.29771;
  int D.29772;
  int D.29773;
  unsigned int D.29774;
  unsigned int D.29775;
  struct MonoMemPool * D.29776;
  void * D.29777;
  unsigned char D.29778;
  unsigned char D.29779;
  struct MonoInst * * D.29782;
  struct MonoClass * D.29783;
  struct MonoType * D.29784;
  struct MonoInst * D.29785;
  int D.29786;
  unsigned int D.29787;
  unsigned int D.29788;
  struct MonoInst * * D.29789;
  struct MonoType * D.29790;
  struct MonoInst * D.29791;
  struct MonoInst * D.29798;
  struct MonoInst * D.29799;
  unsigned int D.29800;
  short unsigned int D.29801;
  unsigned int D.29802;
  unsigned int D.29803;
  void * D.29804;
  struct MonoInst * * D.29807;
  unsigned int i.128;
  unsigned int D.29809;
  struct MonoInst * * D.29810;
  struct MonoType * D.29811;
  struct MonoInst * D.29812;
  int D.29813;
  unsigned char D.29816;
  unsigned char D.29817;
  unsigned char D.29820;
  unsigned char D.29821;
  struct MonoClass * D.29824;
  struct MonoType * D.29825;
  unsigned char D.29826;
  unsigned char D.29827;
  unsigned char D.29828;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  int i;

  header = cfg->header;
  D.29757 = cfg->method;
  sig = mono_method_signature (D.29757);
  D.29758 = sig->ret;
  D.29759 = mono_type_is_void (D.29758);
  if (D.29759 == 0) goto <D.29760>; else goto <D.29761>;
  <D.29760>:
  D.29758 = sig->ret;
  D.29762 = mono_compile_create_var (cfg, D.29758, 330);
  cfg->ret = D.29762;
  D.29763 = cfg->ret;
  D.29763 = cfg->ret;
  D.29764 = D.29763->flags;
  D.29765 = D.29764 | 4;
  D.29763->flags = D.29765;
  <D.29761>:
  D.29766 = cfg->verbose_level;
  if (D.29766 > 2) goto <D.29767>; else goto <D.29768>;
  <D.29767>:
  monoeg_g_print ("creating vars\n");
  <D.29768>:
  D.29769 = sig->param_count;
  D.29770 = (int) D.29769;
  D.29771 = sig->hasthis;
  D.29772 = (int) D.29771;
  D.29773 = D.29770 + D.29772;
  D.29774 = (unsigned int) D.29773;
  D.29775 = D.29774 * 4;
  D.29776 = cfg->mempool;
  D.29777 = mono_mempool_alloc0 (D.29776, D.29775);
  cfg->args = D.29777;
  D.29778 = BIT_FIELD_REF <*sig, 8, 80>;
  D.29779 = D.29778 & 64;
  if (D.29779 != 0) goto <D.29780>; else goto <D.29781>;
  <D.29780>:
  D.29782 = cfg->args;
  D.29757 = cfg->method;
  D.29783 = D.29757->klass;
  D.29784 = &D.29783->this_arg;
  D.29785 = mono_compile_create_var (cfg, D.29784, 330);
  *D.29782 = D.29785;
  <D.29781>:
  i = 0;
  goto <D.25689>;
  <D.25688>:
  D.29782 = cfg->args;
  D.29771 = sig->hasthis;
  D.29772 = (int) D.29771;
  D.29786 = D.29772 + i;
  D.29787 = (unsigned int) D.29786;
  D.29788 = D.29787 * 4;
  D.29789 = D.29782 + D.29788;
  D.29790 = sig->params[i];
  D.29791 = mono_compile_create_var (cfg, D.29790, 330);
  *D.29789 = D.29791;
  i = i + 1;
  <D.25689>:
  D.29769 = sig->param_count;
  D.29770 = (int) D.29769;
  if (D.29770 > i) goto <D.25688>; else goto <D.25690>;
  <D.25690>:
  D.29766 = cfg->verbose_level;
  if (D.29766 > 2) goto <D.29792>; else goto <D.29793>;
  <D.29792>:
  D.29763 = cfg->ret;
  if (D.29763 != 0B) goto <D.29794>; else goto <D.29795>;
  <D.29794>:
  printf ("\treturn : ");
  D.29763 = cfg->ret;
  mono_print_ins (D.29763);
  <D.29795>:
  D.29778 = BIT_FIELD_REF <*sig, 8, 80>;
  D.29779 = D.29778 & 64;
  if (D.29779 != 0) goto <D.29796>; else goto <D.29797>;
  <D.29796>:
  printf ("\tthis: ");
  D.29782 = cfg->args;
  D.29798 = *D.29782;
  mono_print_ins (D.29798);
  <D.29797>:
  i = 0;
  goto <D.25692>;
  <D.25691>:
  printf ("\targ [%d]: ", i);
  D.29782 = cfg->args;
  D.29771 = sig->hasthis;
  D.29772 = (int) D.29771;
  D.29786 = D.29772 + i;
  D.29787 = (unsigned int) D.29786;
  D.29788 = D.29787 * 4;
  D.29789 = D.29782 + D.29788;
  D.29799 = *D.29789;
  mono_print_ins (D.29799);
  i = i + 1;
  <D.25692>:
  D.29769 = sig->param_count;
  D.29770 = (int) D.29769;
  if (D.29770 > i) goto <D.25691>; else goto <D.25693>;
  <D.25693>:
  <D.29793>:
  D.29800 = cfg->num_varinfo;
  cfg->locals_start = D.29800;
  D.29801 = header->num_locals;
  D.29802 = (unsigned int) D.29801;
  D.29803 = D.29802 * 4;
  D.29776 = cfg->mempool;
  D.29804 = mono_mempool_alloc0 (D.29776, D.29803);
  cfg->locals = D.29804;
  D.29766 = cfg->verbose_level;
  if (D.29766 > 2) goto <D.29805>; else goto <D.29806>;
  <D.29805>:
  monoeg_g_print ("creating locals\n");
  <D.29806>:
  i = 0;
  goto <D.25695>;
  <D.25694>:
  D.29807 = cfg->locals;
  i.128 = (unsigned int) i;
  D.29809 = i.128 * 4;
  D.29810 = D.29807 + D.29809;
  D.29811 = header->locals[i];
  D.29812 = mono_compile_create_var (cfg, D.29811, 329);
  *D.29810 = D.29812;
  i = i + 1;
  <D.25695>:
  D.29801 = header->num_locals;
  D.29813 = (int) D.29801;
  if (D.29813 > i) goto <D.25694>; else goto <D.25696>;
  <D.25696>:
  D.29766 = cfg->verbose_level;
  if (D.29766 > 2) goto <D.29814>; else goto <D.29815>;
  <D.29814>:
  monoeg_g_print ("locals done\n");
  <D.29815>:
  mono_arch_create_vars (cfg);
  D.29757 = cfg->method;
  D.29816 = BIT_FIELD_REF <*D.29757, 8, 168>;
  D.29817 = D.29816 & 1;
  if (D.29817 != 0) goto <D.29818>; else goto <D.29819>;
  <D.29818>:
  D.29820 = BIT_FIELD_REF <*cfg, 8, 3416>;
  D.29821 = D.29820 & 2;
  if (D.29821 != 0) goto <D.29822>; else goto <D.29823>;
  <D.29822>:
  {
    struct MonoInst * lmf_var;

    D.29824 = mono_defaults.int_class;
    D.29825 = &D.29824->byval_arg;
    lmf_var = mono_compile_create_var (cfg, D.29825, 329);
    D.29826 = lmf_var->flags;
    D.29827 = D.29826 | 4;
    lmf_var->flags = D.29827;
    D.29826 = lmf_var->flags;
    D.29828 = D.29826 | 32;
    lmf_var->flags = D.29828;
    cfg->lmf_var = lmf_var;
  }
  <D.29823>:
  <D.29819>:
}


mono_handle_out_of_line_bblock (struct MonoCompile * cfg)
{
  struct MonoBasicBlock * D.29829;
  unsigned char D.29832;
  unsigned char D.29833;
  struct MonoInst * D.29836;
  short unsigned int D.29839;
  short unsigned int D.29840;
  _Bool D.29841;
  short unsigned int D.29842;
  _Bool D.29843;
  _Bool D.29844;
  short unsigned int D.29847;
  short unsigned int D.29848;
  struct MonoMemPool * D.29857;
  int D.29858;
  struct MonoInst * D.29859;
  int D.29860;
  int D.29861;
  const unsigned char * D.29862;
  struct MonoBasicBlock * bb;

  bb = cfg->bb_entry;
  goto <D.25825>;
  <D.25824>:
  D.29829 = bb->next_bb;
  if (D.29829 != 0B) goto <D.29830>; else goto <D.29831>;
  <D.29830>:
  D.29829 = bb->next_bb;
  D.29832 = BIT_FIELD_REF <*D.29829, 8, 912>;
  D.29833 = D.29832 & 1;
  if (D.29833 != 0) goto <D.29834>; else goto <D.29835>;
  <D.29834>:
  D.29836 = bb->last_ins;
  if (D.29836 != 0B) goto <D.29837>; else goto <D.29838>;
  <D.29837>:
  D.29836 = bb->last_ins;
  D.29839 = D.29836->opcode;
  D.29840 = D.29839 + 64981;
  D.29841 = D.29840 > 9;
  D.29842 = D.29839 + 64874;
  D.29843 = D.29842 > 9;
  D.29844 = D.29841 & D.29843;
  if (D.29844 != 0) goto <D.29845>; else goto <D.29846>;
  <D.29845>:
  D.29836 = bb->last_ins;
  D.29847 = D.29836->opcode;
  D.29848 = D.29847 + 64884;
  if (D.29848 > 9) goto <D.29849>; else goto <D.29850>;
  <D.29849>:
  D.29836 = bb->last_ins;
  D.29847 = D.29836->opcode;
  if (D.29847 != 446) goto <D.29851>; else goto <D.29852>;
  <D.29851>:
  D.29836 = bb->last_ins;
  D.29847 = D.29836->opcode;
  if (D.29847 != 763) goto <D.29853>; else goto <D.29854>;
  <D.29853>:
  D.29836 = bb->last_ins;
  D.29847 = D.29836->opcode;
  if (D.29847 != 370) goto <D.29855>; else goto <D.29856>;
  <D.29855>:
  {
    struct MonoInst * ins;

    D.29857 = cfg->mempool;
    ins = mono_mempool_alloc (D.29857, 48);
    ins->data.op[1].const_val = 0;
    D.29858 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.29858;
    ins->prev = 0B;
    D.29859 = ins->prev;
    ins->next = D.29859;
    ins->opcode = 446;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.29860 = ins->sreg3;
    ins->sreg2 = D.29860;
    D.29861 = ins->sreg2;
    ins->sreg1 = D.29861;
    D.29862 = cfg->ip;
    ins->cil_code = D.29862;
    D.29836 = bb->last_ins;
    if (D.29836 != 0B) goto <D.29863>; else goto <D.29864>;
    <D.29863>:
    D.29836 = bb->last_ins;
    D.29836->next = ins;
    D.29836 = bb->last_ins;
    ins->prev = D.29836;
    bb->last_ins = ins;
    goto <D.29865>;
    <D.29864>:
    bb->last_ins = ins;
    D.29836 = bb->last_ins;
    bb->code = D.29836;
    <D.29865>:
    D.29829 = bb->next_bb;
    ins->data.op[0].target_block = D.29829;
  }
  <D.29856>:
  <D.29854>:
  <D.29852>:
  <D.29850>:
  <D.29846>:
  <D.29838>:
  <D.29835>:
  <D.29831>:
  bb = bb->next_bb;
  <D.25825>:
  if (bb != 0B) goto <D.25824>; else goto <D.25826>;
  <D.25826>:
}


compute_reachable (struct MonoBasicBlock * bb)
{
  unsigned int D.29866;
  unsigned int D.29867;
  unsigned int D.29870;
  struct MonoBasicBlock * * D.29871;
  unsigned int i.129;
  unsigned int D.29873;
  struct MonoBasicBlock * * D.29874;
  struct MonoBasicBlock * D.29875;
  short int D.29876;
  int D.29877;
  int i;

  D.29866 = bb->flags;
  D.29867 = D.29866 & 1;
  if (D.29867 == 0) goto <D.29868>; else goto <D.29869>;
  <D.29868>:
  D.29866 = bb->flags;
  D.29870 = D.29866 | 1;
  bb->flags = D.29870;
  i = 0;
  goto <D.25817>;
  <D.25816>:
  D.29871 = bb->out_bb;
  i.129 = (unsigned int) i;
  D.29873 = i.129 * 4;
  D.29874 = D.29871 + D.29873;
  D.29875 = *D.29874;
  compute_reachable (D.29875);
  i = i + 1;
  <D.25817>:
  D.29876 = bb->out_count;
  D.29877 = (int) D.29876;
  if (D.29877 > i) goto <D.25816>; else goto <D.25818>;
  <D.25818>:
  <D.29869>:
}


print_dfn (struct MonoCompile * cfg)
{
  struct MonoMethod * D.29878;
  struct MonoBasicBlock * * D.29879;
  unsigned int i.130;
  unsigned int D.29881;
  struct MonoBasicBlock * * D.29882;
  int D.29883;
  int D.29884;
  struct MonoBasicBlock * * D.29885;
  unsigned int j.131;
  unsigned int D.29887;
  struct MonoBasicBlock * * D.29888;
  struct MonoBasicBlock * D.29889;
  int D.29890;
  short int D.29891;
  int D.29892;
  struct MonoBasicBlock * * D.29893;
  struct MonoBasicBlock * * D.29894;
  struct MonoBasicBlock * D.29895;
  int D.29896;
  short int D.29897;
  int D.29898;
  int iftmp.132;
  struct MonoBasicBlock * D.29900;
  struct MonoBitSet * D.29906;
  int D.29907;
  unsigned int D.29908;
  unsigned int D.29909;
  unsigned int D.29910;
  int D.29911;
  unsigned int D.29912;
  unsigned int D.29913;
  _Bool D.29914;
  long int D.29915;
  long int D.29916;
  guint iftmp.133;
  struct MonoBitSet * D.29925;
  unsigned int i.134;
  unsigned int D.29929;
  int i;
  int j;
  char * code;
  struct MonoBasicBlock * bb;
  struct MonoInst * c;

  {
    char * method_name;

    D.29878 = cfg->method;
    method_name = mono_method_full_name (D.29878, 1);
    monoeg_g_print ("IR code for method %s\n", method_name);
    monoeg_g_free (method_name);
  }
  i = 0;
  goto <D.25283>;
  <D.25282>:
  D.29879 = cfg->bblocks;
  i.130 = (unsigned int) i;
  D.29881 = i.130 * 4;
  D.29882 = D.29879 + D.29881;
  bb = *D.29882;
  code = monoeg_strdup ("\n");
  D.29883 = bb->cil_length;
  D.29884 = bb->block_num;
  monoeg_g_print ("\nBB%d (%d) (len: %d): %s", D.29884, i, D.29883, code);
  c = bb->code;
  goto <D.25274>;
  <D.25273>:
  mono_print_ins_index (-1, c);
  c = c->next;
  <D.25274>:
  if (c != 0B) goto <D.25273>; else goto <D.25275>;
  <D.25275>:
  monoeg_g_print ("\tprev:");
  j = 0;
  goto <D.25277>;
  <D.25276>:
  D.29885 = bb->in_bb;
  j.131 = (unsigned int) j;
  D.29887 = j.131 * 4;
  D.29888 = D.29885 + D.29887;
  D.29889 = *D.29888;
  D.29890 = D.29889->block_num;
  monoeg_g_print (" BB%d", D.29890);
  j = j + 1;
  <D.25277>:
  D.29891 = bb->in_count;
  D.29892 = (int) D.29891;
  if (D.29892 > j) goto <D.25276>; else goto <D.25278>;
  <D.25278>:
  monoeg_g_print ("\t\tsucc:");
  j = 0;
  goto <D.25280>;
  <D.25279>:
  D.29893 = bb->out_bb;
  j.131 = (unsigned int) j;
  D.29887 = j.131 * 4;
  D.29894 = D.29893 + D.29887;
  D.29895 = *D.29894;
  D.29896 = D.29895->block_num;
  monoeg_g_print (" BB%d", D.29896);
  j = j + 1;
  <D.25280>:
  D.29897 = bb->out_count;
  D.29898 = (int) D.29897;
  if (D.29898 > j) goto <D.25279>; else goto <D.25281>;
  <D.25281>:
  D.29900 = bb->idom;
  if (D.29900 != 0B) goto <D.29901>; else goto <D.29902>;
  <D.29901>:
  D.29900 = bb->idom;
  iftmp.132 = D.29900->block_num;
  goto <D.29903>;
  <D.29902>:
  iftmp.132 = -1;
  <D.29903>:
  monoeg_g_print ("\n\tidom: BB%d\n", iftmp.132);
  D.29900 = bb->idom;
  if (D.29900 != 0B) goto <D.29904>; else goto <D.29905>;
  <D.29904>:
  D.29906 = bb->dominators;
  D.29900 = bb->idom;
  D.29907 = D.29900->dfn;
  D.29908 = (unsigned int) D.29907;
  D.29909 = D.29908 / 32;
  D.29910 = D.29906->data[D.29909];
  D.29900 = bb->idom;
  D.29907 = D.29900->dfn;
  D.29911 = D.29907 & 31;
  D.29912 = 1 << D.29911;
  D.29913 = D.29910 & D.29912;
  D.29914 = D.29913 == 0;
  D.29915 = (long int) D.29914;
  D.29916 = __builtin_expect (D.29915, 0);
  if (D.29916 != 0) goto <D.29917>; else goto <D.29918>;
  <D.29917>:
  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.29918>:
  <D.29905>:
  D.29906 = bb->dominators;
  if (D.29906 != 0B) goto <D.29919>; else goto <D.29920>;
  <D.29919>:
  D.29900 = bb->idom;
  if (D.29900 != 0B) goto <D.29922>; else goto <D.29923>;
  <D.29922>:
  D.29900 = bb->idom;
  D.29907 = D.29900->dfn;
  iftmp.133 = (guint) D.29907;
  goto <D.29924>;
  <D.29923>:
  iftmp.133 = 4294967295;
  <D.29924>:
  D.29906 = bb->dominators;
  mono_blockset_print (cfg, D.29906, "\tdominators", iftmp.133);
  <D.29920>:
  D.29925 = bb->dfrontier;
  if (D.29925 != 0B) goto <D.29926>; else goto <D.29927>;
  <D.29926>:
  D.29925 = bb->dfrontier;
  mono_blockset_print (cfg, D.29925, "\tdfrontier", 4294967295);
  <D.29927>:
  monoeg_g_free (code);
  i = i + 1;
  <D.25283>:
  i.134 = (unsigned int) i;
  D.29929 = cfg->num_bblocks;
  if (i.134 < D.29929) goto <D.25282>; else goto <D.25284>;
  <D.25284>:
  monoeg_g_print ("\n");
}


df_visit (struct MonoBasicBlock * start, int * dfn, struct MonoBasicBlock * * array)
{
  int D.29930;
  unsigned int D.29931;
  unsigned int D.29932;
  struct MonoBasicBlock * * D.29933;
  struct MonoBasicBlock * * D.29934;
  unsigned int i.135;
  unsigned int D.29936;
  struct MonoBasicBlock * * D.29937;
  struct MonoBasicBlock * D.29938;
  int D.29939;
  int D.29942;
  short int D.29943;
  int D.29944;
  int i;

  D.29930 = *dfn;
  D.29931 = (unsigned int) D.29930;
  D.29932 = D.29931 * 4;
  D.29933 = array + D.29932;
  *D.29933 = start;
  i = 0;
  goto <D.24777>;
  <D.24776>:
  D.29934 = start->out_bb;
  i.135 = (unsigned int) i;
  D.29936 = i.135 * 4;
  D.29937 = D.29934 + D.29936;
  D.29938 = *D.29937;
  D.29939 = D.29938->dfn;
  if (D.29939 != 0) goto <D.29940>; else goto <D.29941>;
  <D.29940>:
  // predicted unlikely by continue predictor.
  goto <D.24775>;
  <D.29941>:
  D.29930 = *dfn;
  D.29942 = D.29930 + 1;
  *dfn = D.29942;
  D.29934 = start->out_bb;
  i.135 = (unsigned int) i;
  D.29936 = i.135 * 4;
  D.29937 = D.29934 + D.29936;
  D.29938 = *D.29937;
  D.29930 = *dfn;
  D.29938->dfn = D.29930;
  D.29934 = start->out_bb;
  i.135 = (unsigned int) i;
  D.29936 = i.135 * 4;
  D.29937 = D.29934 + D.29936;
  D.29938 = *D.29937;
  D.29938->df_parent = start;
  D.29930 = *dfn;
  D.29931 = (unsigned int) D.29930;
  D.29932 = D.29931 * 4;
  D.29933 = array + D.29932;
  D.29934 = start->out_bb;
  i.135 = (unsigned int) i;
  D.29936 = i.135 * 4;
  D.29937 = D.29934 + D.29936;
  D.29938 = *D.29937;
  *D.29933 = D.29938;
  D.29934 = start->out_bb;
  i.135 = (unsigned int) i;
  D.29936 = i.135 * 4;
  D.29937 = D.29934 + D.29936;
  D.29938 = *D.29937;
  df_visit (D.29938, dfn, array);
  <D.24775>:
  i = i + 1;
  <D.24777>:
  D.29943 = start->out_count;
  D.29944 = (int) D.29943;
  if (D.29944 > i) goto <D.24776>; else goto <D.24778>;
  <D.24778>:
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.29945;
  unsigned int D.29946;

  D.29946 = __sync_add_and_fetch_4 (val, 1);
  D.29945 = (gint32) D.29946;
  return D.29945;
}


create_jit_info (struct MonoCompile * cfg, struct MonoMethod * method_to_compile)
{
  struct MonoMethod * D.29948;
  _Bool D.29949;
  long int D.29950;
  long int D.29951;
  struct MonoGenericSharingContext * D.29954;
  unsigned char D.29958;
  unsigned char D.29959;
  struct MonoMethod * D.29962;
  short unsigned int D.29963;
  int D.29964;
  int D.29965;
  unsigned int D.29966;
  unsigned int D.29967;
  int D.29968;
  struct GSList * D.29971;
  struct MonoBasicBlock * D.29974;
  int D.29975;
  int D.29976;
  struct MonoBasicBlock * * D.29977;
  unsigned int D.29978;
  unsigned int D.29979;
  unsigned int D.29980;
  unsigned int D.29981;
  struct MonoBasicBlock * * D.29982;
  _Bool D.29983;
  long int D.29984;
  long int D.29985;
  int D.29988;
  unsigned int num_holes.136;
  unsigned int D.29994;
  unsigned int D.29995;
  unsigned int D.29996;
  _Bool D.29997;
  long int D.29998;
  long int D.29999;
  unsigned char D.30002;
  unsigned int D.30007;
  <unnamed-unsigned:15> D.30009;
  unsigned char D.30010;
  unsigned char D.30011;
  unsigned int num_clauses.137;
  unsigned int D.30015;
  unsigned int generic_info_size.138;
  unsigned int D.30017;
  unsigned int holes_size.139;
  unsigned int D.30019;
  unsigned int arch_eh_info_size.140;
  unsigned int D.30021;
  unsigned int cas_size.141;
  unsigned int D.30023;
  unsigned int D.30024;
  struct MonoDomain * D.30026;
  unsigned char * D.30027;
  unsigned int D.30028;
  int D.30029;
  unsigned int D.30030;
  unsigned int D.30031;
  unsigned int D.30032;
  _Bool D.30033;
  <unnamed-signed:1> D.30034;
  short unsigned int D.30035;
  <unnamed-unsigned:15> D.30036;
  _Bool D.30041;
  long int D.30042;
  long int D.30043;
  void * D.30048;
  void * D.30050;
  struct MonoGenericSharingContext * D.30051;
  short unsigned int D.30054;
  int D.30055;
  int D.30056;
  struct MonoGenericContext * D.30058;
  struct MonoGenericInst * D.30059;
  struct MonoClass * D.30061;
  unsigned char D.30062;
  unsigned char D.30063;
  struct MonoInst * D.30064;
  _Bool D.30065;
  long int D.30066;
  long int D.30067;
  struct MonoGenericContext * D.30074;
  struct MonoGenericInst * D.30075;
  short unsigned int D.30079;
  _Bool D.30080;
  long int D.30081;
  long int D.30082;
  struct MonoInst * * D.30085;
  unsigned int D.30088;
  int D.30089;
  int D.30092;
  unsigned int D.30093;
  unsigned int D.30094;
  void * D.30095;
  void * D.30097;
  void * D.30098;
  struct MonoDwarfLocListEntry * D.30099;
  unsigned int i.142;
  unsigned int D.30101;
  struct MonoDwarfLocListEntry * D.30102;
  int D.30105;
  _Bool D.30106;
  long int D.30107;
  long int D.30108;
  unsigned char D.30111;
  int D.30112;
  int D.30116;
  unsigned char D.30117;
  int D.30121;
  _Bool D.30122;
  long int D.30123;
  long int D.30124;
  unsigned char D.30129;
  int D.30130;
  short unsigned int D.30133;
  struct MonoBasicBlock * D.30134;
  int D.30135;
  int D.30136;
  unsigned int D.30137;
  unsigned int D.30138;
  unsigned int D.30139;
  unsigned int D.30140;
  struct MonoBasicBlock * * D.30141;
  _Bool D.30142;
  long int D.30143;
  long int D.30144;
  int D.30147;
  int D.30150;
  int D.30151;
  int i.143;
  struct MonoExceptionClause * D.30153;
  int D.30154;
  struct MonoExceptionClause * D.30155;
  int D.30156;
  int D.30157;
  int D.30158;
  short unsigned int D.30159;
  unsigned int D.30160;
  short unsigned int D.30161;
  short unsigned int D.30162;
  short unsigned int D.30163;
  short unsigned int D.30166;
  int D.30167;
  unsigned int D.30168;
  short unsigned int D.30169;
  int D.30170;
  _Bool D.30171;
  long int D.30172;
  long int D.30173;
  struct MonoJitExceptionInfo * D.30184;
  struct MonoJitExceptionInfo * D.30185;
  short unsigned int D.30187;
  short unsigned int D.30188;
  unsigned int i.144;
  unsigned int D.30192;
  unsigned int D.30193;
  unsigned int D.30194;
  int D.30195;
  int iftmp.145;
  unsigned int D.30200;
  unsigned int D.30203;
  unsigned int D.30204;
  struct MonoBasicBlock * * D.30205;
  _Bool D.30206;
  long int D.30207;
  long int D.30208;
  int D.30211;
  sizetype D.30212;
  void * D.30213;
  struct MonoClass * D.30215;
  unsigned int D.30216;
  unsigned int D.30217;
  struct MonoBasicBlock * * D.30218;
  _Bool D.30221;
  long int D.30222;
  long int D.30223;
  unsigned char D.30226;
  unsigned char D.30227;
  void * D.30230;
  void * D.30231;
  unsigned int D.30232;
  unsigned int D.30233;
  unsigned int D.30234;
  struct MonoBasicBlock * * D.30235;
  unsigned int j.146;
  unsigned int D.30241;
  struct MonoBasicBlock * * D.30242;
  int D.30245;
  unsigned int D.30250;
  struct MonoBasicBlock * * D.30251;
  struct MonoBasicBlock * D.30254;
  int D.30255;
  int D.30256;
  int D.30257;
  sizetype D.30258;
  struct MonoExceptionClause * D.30259;
  void * D.30262;
  int D.30267;
  int D.30268;
  int D.30269;
  int D.30270;
  sizetype D.30271;
  void * D.30272;
  unsigned int D.30275;
  unsigned int D.30276;
  unsigned int D.30277;
  unsigned int D.30280;
  struct MonoBasicBlock * * D.30281;
  unsigned int j.147;
  unsigned int D.30286;
  struct MonoBasicBlock * * D.30287;
  int D.30290;
  int D.30293;
  unsigned int D.30295;
  sizetype end_offset.148;
  void * D.30297;
  int D.30298;
  void * D.30301;
  int D.30302;
  void * D.30303;
  int D.30304;
  void * D.30305;
  int D.30306;
  void * D.30307;
  int D.30308;
  unsigned int D.30309;
  <unnamed-unsigned:15> D.30310;
  int D.30311;
  guint8 * D.30312;
  unsigned int D.30315;
  unsigned int D.30316;
  struct GSList * D.30318;
  unsigned int info_len.149;
  unsigned int D.30322;
  struct MonoJitInfo * D.30323;
  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.29948 = cfg->method;
  D.29949 = D.29948 != method_to_compile;
  D.29950 = (long int) D.29949;
  D.29951 = __builtin_expect (D.29950, 0);
  if (D.29951 != 0) goto <D.29952>; else goto <D.29953>;
  <D.29952>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4280, "method_to_compile == cfg->method");
  <D.29953>:
  header = cfg->header;
  D.29954 = cfg->generic_sharing_context;
  if (D.29954 != 0B) goto <D.29955>; else goto <D.29956>;
  <D.29955>:
  generic_info_size = 20;
  goto <D.29957>;
  <D.29956>:
  generic_info_size = 0;
  <D.29957>:
  D.29958 = BIT_FIELD_REF <*cfg, 8, 3432>;
  D.29959 = D.29958 & 2;
  if (D.29959 != 0) goto <D.29960>; else goto <D.29961>;
  <D.29960>:
  {
    struct MonoJitArgumentInfo * arg_info;
    struct MonoMethodSignature * sig;

    D.29962 = cfg->method_to_register;
    sig = mono_method_signature (D.29962);
    D.29963 = sig->param_count;
    D.29964 = (int) D.29963;
    D.29965 = D.29964 + 1;
    D.29966 = (unsigned int) D.29965;
    D.29967 = D.29966 * 6;
    arg_info = __builtin_alloca (D.29967);
    D.29963 = sig->param_count;
    D.29964 = (int) D.29963;
    D.29954 = cfg->generic_sharing_context;
    D.29968 = mono_arch_get_argument_info (D.29954, sig, D.29964, arg_info);
    stack_size = (guint32) D.29968;
    if (stack_size != 0) goto <D.29969>; else goto <D.29970>;
    <D.29969>:
    arch_eh_info_size = 4;
    <D.29970>:
  }
  <D.29961>:
  D.29971 = cfg->try_block_holes;
  if (D.29971 != 0B) goto <D.29972>; else goto <D.29973>;
  <D.29972>:
  tmp = cfg->try_block_holes;
  goto <D.25856>;
  <D.25855>:
  {
    struct TryBlockHole * hole;
    struct MonoExceptionClause * ec;
    int hole_end;
    struct MonoBasicBlock * clause_last_bb;

    hole = tmp->data;
    ec = hole->clause;
    D.29974 = hole->basic_block;
    D.29975 = D.29974->native_offset;
    D.29974 = hole->basic_block;
    D.29976 = D.29974->native_length;
    hole_end = D.29975 + D.29976;
    D.29977 = cfg->cil_offset_to_bb;
    D.29978 = ec->try_offset;
    D.29979 = ec->try_len;
    D.29980 = D.29978 + D.29979;
    D.29981 = D.29980 * 4;
    D.29982 = D.29977 + D.29981;
    clause_last_bb = *D.29982;
    D.29983 = clause_last_bb == 0B;
    D.29984 = (long int) D.29983;
    D.29985 = __builtin_expect (D.29984, 0);
    if (D.29985 != 0) goto <D.29986>; else goto <D.29987>;
    <D.29986>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4309, "clause_last_bb");
    <D.29987>:
    D.29988 = clause_last_bb->native_offset;
    if (D.29988 != hole_end) goto <D.29989>; else goto <D.29990>;
    <D.29989>:
    num_holes = num_holes + 1;
    <D.29990>:
  }
  tmp = tmp->next;
  <D.25856>:
  if (tmp != 0B) goto <D.25855>; else goto <D.25857>;
  <D.25857>:
  if (num_holes != 0) goto <D.29991>; else goto <D.29992>;
  <D.29991>:
  num_holes.136 = (unsigned int) num_holes;
  D.29994 = num_holes.136 * 8;
  D.29995 = D.29994 + 4;
  holes_size = (int) D.29995;
  <D.29992>:
  D.29996 = cfg->verbose_level;
  D.29997 = D.29996 > 3;
  D.29998 = (long int) D.29997;
  D.29999 = __builtin_expect (D.29998, 0);
  if (D.29999 != 0) goto <D.30000>; else goto <D.30001>;
  <D.30000>:
  printf ("Number of try block holes %d\n", num_holes);
  <D.30001>:
  <D.29973>:
  D.29962 = cfg->method_to_register;
  D.30002 = mono_method_has_declsec (D.29962);
  if (D.30002 != 0) goto <D.30003>; else goto <D.30004>;
  <D.30003>:
  cas_size = 4;
  <D.30004>:
  if (0 != 0) goto <D.30005>; else goto <D.30006>;
  <D.30005>:
  D.30007 = cfg->llvm_ex_info_len;
  num_clauses = (int) D.30007;
  goto <D.30008>;
  <D.30006>:
  D.30009 = header->num_clauses;
  num_clauses = (int) D.30009;
  <D.30008>:
  D.29948 = cfg->method;
  D.30010 = BIT_FIELD_REF <*D.29948, 8, 168>;
  D.30011 = D.30010 & 2;
  if (D.30011 != 0) goto <D.30012>; else goto <D.30013>;
  <D.30012>:
  num_clauses.137 = (unsigned int) num_clauses;
  D.30015 = num_clauses.137 * 24;
  generic_info_size.138 = (unsigned int) generic_info_size;
  D.30017 = D.30015 + generic_info_size.138;
  holes_size.139 = (unsigned int) holes_size;
  D.30019 = D.30017 + holes_size.139;
  arch_eh_info_size.140 = (unsigned int) arch_eh_info_size;
  D.30021 = D.30019 + arch_eh_info_size.140;
  cas_size.141 = (unsigned int) cas_size;
  D.30023 = D.30021 + cas_size.141;
  D.30024 = D.30023 + 28;
  jinfo = monoeg_malloc0 (D.30024);
  goto <D.30025>;
  <D.30013>:
  num_clauses.137 = (unsigned int) num_clauses;
  D.30015 = num_clauses.137 * 24;
  generic_info_size.138 = (unsigned int) generic_info_size;
  D.30017 = D.30015 + generic_info_size.138;
  holes_size.139 = (unsigned int) holes_size;
  D.30019 = D.30017 + holes_size.139;
  arch_eh_info_size.140 = (unsigned int) arch_eh_info_size;
  D.30021 = D.30019 + arch_eh_info_size.140;
  cas_size.141 = (unsigned int) cas_size;
  D.30023 = D.30021 + cas_size.141;
  D.30024 = D.30023 + 28;
  D.30026 = cfg->domain;
  jinfo = mono_domain_alloc0 (D.30026, D.30024);
  <D.30025>:
  D.29962 = cfg->method_to_register;
  jinfo->d.method = D.29962;
  D.30027 = cfg->native_code;
  jinfo->code_start = D.30027;
  D.30028 = cfg->code_len;
  D.30029 = (int) D.30028;
  jinfo->code_size = D.30029;
  D.30030 = cfg->used_int_regs;
  jinfo->used_regs = D.30030;
  D.30031 = cfg->opt;
  D.30032 = D.30031 & 512;
  D.30033 = D.30032 != 0;
  D.30034 = (<unnamed-signed:1>) D.30033;
  jinfo->domain_neutral = D.30034;
  D.30035 = (short unsigned int) num_clauses;
  D.30036 = (<unnamed-unsigned:15>) D.30035;
  jinfo->num_clauses = D.30036;
  if (0 != 0) goto <D.30037>; else goto <D.30038>;
  <D.30037>:
  jinfo->from_llvm = -1;
  <D.30038>:
  D.29954 = cfg->generic_sharing_context;
  if (D.29954 != 0B) goto <D.30039>; else goto <D.30040>;
  <D.30039>:
  {
    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.30041 = gi == 0B;
    D.30042 = (long int) D.30041;
    D.30043 = __builtin_expect (D.30042, 0);
    if (D.30043 != 0) goto <D.30044>; else goto <D.30045>;
    <D.30044>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4357, "gi");
    <D.30045>:
    D.29948 = cfg->method;
    D.30010 = BIT_FIELD_REF <*D.29948, 8, 168>;
    D.30011 = D.30010 & 2;
    if (D.30011 != 0) goto <D.30046>; else goto <D.30047>;
    <D.30046>:
    D.30048 = monoeg_malloc0 (8);
    gi->generic_sharing_context = D.30048;
    goto <D.30049>;
    <D.30047>:
    D.30026 = cfg->domain;
    D.30050 = mono_domain_alloc0 (D.30026, 8);
    gi->generic_sharing_context = D.30050;
    <D.30049>:
    D.29954 = cfg->generic_sharing_context;
    D.30051 = gi->generic_sharing_context;
    memcpy (D.30051, D.29954, 8);
    D.30054 = method_to_compile->flags;
    D.30055 = (int) D.30054;
    D.30056 = D.30055 & 16;
    if (D.30056 != 0) goto <D.30052>; else goto <D.30057>;
    <D.30057>:
    D.30058 = mini_method_get_context (method_to_compile);
    D.30059 = D.30058->method_inst;
    if (D.30059 != 0B) goto <D.30052>; else goto <D.30060>;
    <D.30060>:
    D.30061 = method_to_compile->klass;
    D.30062 = BIT_FIELD_REF <*D.30061, 8, 160>;
    D.30063 = D.30062 & 8;
    if (D.30063 != 0) goto <D.30052>; else goto <D.30053>;
    <D.30052>:
    D.30064 = cfg->rgctx_var;
    D.30065 = D.30064 == 0B;
    D.30066 = (long int) D.30065;
    D.30067 = __builtin_expect (D.30066, 0);
    if (D.30067 != 0) goto <D.30068>; else goto <D.30069>;
    <D.30068>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4368, "cfg->rgctx_var");
    <D.30069>:
    <D.30053>:
    gi->has_this = -1;
    D.30054 = method_to_compile->flags;
    D.30055 = (int) D.30054;
    D.30056 = D.30055 & 16;
    if (D.30056 != 0) goto <D.30070>; else goto <D.30073>;
    <D.30073>:
    D.30074 = mini_method_get_context (method_to_compile);
    D.30075 = D.30074->method_inst;
    if (D.30075 != 0B) goto <D.30070>; else goto <D.30076>;
    <D.30076>:
    D.30061 = method_to_compile->klass;
    D.30062 = BIT_FIELD_REF <*D.30061, 8, 160>;
    D.30063 = D.30062 & 8;
    if (D.30063 != 0) goto <D.30070>; else goto <D.30071>;
    <D.30070>:
    inst = cfg->rgctx_var;
    if (1 != 0) goto <D.30077>; else goto <D.30078>;
    <D.30077>:
    D.30079 = inst->opcode;
    D.30080 = D.30079 != 367;
    D.30081 = (long int) D.30080;
    D.30082 = __builtin_expect (D.30081, 0);
    if (D.30082 != 0) goto <D.30083>; else goto <D.30084>;
    <D.30083>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4378, "inst->opcode == OP_REGOFFSET");
    <D.30084>:
    <D.30078>:
    loclist = cfg->rgctx_loclist;
    goto <D.30072>;
    <D.30071>:
    D.30085 = cfg->args;
    inst = *D.30085;
    loclist = cfg->this_loclist;
    <D.30072>:
    if (loclist != 0B) goto <D.30086>; else goto <D.30087>;
    <D.30086>:
    {
      struct GSList * l;
      int i;

      D.30088 = monoeg_g_slist_length (loclist);
      D.30089 = (int) D.30088;
      gi->nlocs = D.30089;
      D.29948 = cfg->method;
      D.30010 = BIT_FIELD_REF <*D.29948, 8, 168>;
      D.30011 = D.30010 & 2;
      if (D.30011 != 0) goto <D.30090>; else goto <D.30091>;
      <D.30090>:
      D.30092 = gi->nlocs;
      D.30093 = (unsigned int) D.30092;
      D.30094 = D.30093 * 20;
      D.30095 = monoeg_malloc0 (D.30094);
      gi->locations = D.30095;
      goto <D.30096>;
      <D.30091>:
      D.30092 = gi->nlocs;
      D.30093 = (unsigned int) D.30092;
      D.30094 = D.30093 * 20;
      D.30026 = cfg->domain;
      D.30097 = mono_domain_alloc0 (D.30026, D.30094);
      gi->locations = D.30097;
      <D.30096>:
      i = 0;
      l = loclist;
      goto <D.25864>;
      <D.25863>:
      D.30098 = l->data;
      D.30099 = gi->locations;
      i.142 = (unsigned int) i;
      D.30101 = i.142 * 20;
      D.30102 = D.30099 + D.30101;
      memcpy (D.30102, D.30098, 20);
      i = i + 1;
      l = l->next;
      <D.25864>:
      if (l != 0B) goto <D.25863>; else goto <D.25865>;
      <D.25865>:
    }
    <D.30087>:
    if (0 != 0) goto <D.30103>; else goto <D.30104>;
    <D.30103>:
    D.30105 = cfg->llvm_this_reg;
    D.30106 = D.30105 == -1;
    D.30107 = (long int) D.30106;
    D.30108 = __builtin_expect (D.30107, 0);
    if (D.30108 != 0) goto <D.30109>; else goto <D.30110>;
    <D.30109>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4403, "cfg->llvm_this_reg != -1");
    <D.30110>:
    gi->this_in_reg = 0;
    D.30105 = cfg->llvm_this_reg;
    D.30111 = (unsigned char) D.30105;
    gi->this_reg = D.30111;
    D.30112 = cfg->llvm_this_offset;
    gi->this_offset = D.30112;
    goto <D.30113>;
    <D.30104>:
    D.30079 = inst->opcode;
    if (D.30079 == 366) goto <D.30114>; else goto <D.30115>;
    <D.30114>:
    gi->this_in_reg = -1;
    D.30116 = inst->dreg;
    D.30117 = (unsigned char) D.30116;
    gi->this_reg = D.30117;
    goto <D.30118>;
    <D.30115>:
    D.30079 = inst->opcode;
    D.30080 = D.30079 != 367;
    D.30081 = (long int) D.30080;
    D.30082 = __builtin_expect (D.30081, 0);
    if (D.30082 != 0) goto <D.30119>; else goto <D.30120>;
    <D.30119>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4411, "inst->opcode == OP_REGOFFSET");
    <D.30120>:
    D.30121 = inst->sreg1;
    D.30122 = D.30121 != 5;
    D.30123 = (long int) D.30122;
    D.30124 = __builtin_expect (D.30123, 0);
    if (D.30124 != 0) goto <D.30125>; else goto <D.30126>;
    <D.30125>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4413, "inst->inst_basereg == X86_EBP");
    <D.30126>:
    if (0 != 0) goto <D.30127>; else goto <D.30128>;
    <D.30127>:
    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.30128>:
    gi->this_in_reg = 0;
    D.30121 = inst->sreg1;
    D.30129 = (unsigned char) D.30121;
    gi->this_reg = D.30129;
    D.30130 = inst->data.op[0].const_val;
    gi->this_offset = D.30130;
    <D.30118>:
    <D.30113>:
  }
  <D.30040>:
  if (num_holes != 0) goto <D.30131>; else goto <D.30132>;
  <D.30131>:
  {
    struct MonoTryBlockHoleTableJitInfo * table;
    int i;

    jinfo->has_try_block_holes = -1;
    table = mono_jit_info_get_try_block_hole_table_info (jinfo);
    D.30133 = (short unsigned int) num_holes;
    table->num_holes = D.30133;
    i = 0;
    tmp = cfg->try_block_holes;
    goto <D.25876>;
    <D.25875>:
    {
      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.30134 = hole_data->basic_block;
      D.30135 = D.30134->native_offset;
      D.30134 = hole_data->basic_block;
      D.30136 = D.30134->native_length;
      hole_end = D.30135 + D.30136;
      D.29977 = cfg->cil_offset_to_bb;
      D.30137 = ec->try_offset;
      D.30138 = ec->try_len;
      D.30139 = D.30137 + D.30138;
      D.30140 = D.30139 * 4;
      D.30141 = D.29977 + D.30140;
      clause_last_bb = *D.30141;
      D.30142 = clause_last_bb == 0B;
      D.30143 = (long int) D.30142;
      D.30144 = __builtin_expect (D.30143, 0);
      if (D.30144 != 0) goto <D.30145>; else goto <D.30146>;
      <D.30145>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4440, "clause_last_bb");
      <D.30146>:
      D.30147 = clause_last_bb->native_offset;
      if (D.30147 == hole_end) goto <D.30148>; else goto <D.30149>;
      <D.30148>:
      // predicted unlikely by continue predictor.
      goto <D.25874>;
      <D.30149>:
      D.30150 = hole_data->start_offset;
      D.30134 = hole_data->basic_block;
      D.30135 = D.30134->native_offset;
      D.30151 = D.30150 - D.30135;
      start_bb_offset = (guint32) D.30151;
      i.143 = i;
      i = i.143 + 1;
      hole = &table->holes[i.143];
      D.30153 = hole_data->clause;
      D.30154 = (int) D.30153;
      D.30155 = header->clauses;
      D.30156 = (int) D.30155;
      D.30157 = D.30154 - D.30156;
      D.30158 = D.30157 /[ex] 24;
      D.30159 = (short unsigned int) D.30158;
      hole->clause = D.30159;
      D.30150 = hole_data->start_offset;
      D.30160 = (unsigned int) D.30150;
      hole->offset = D.30160;
      D.30134 = hole_data->basic_block;
      D.30136 = D.30134->native_length;
      D.30161 = (short unsigned int) D.30136;
      D.30162 = (short unsigned int) start_bb_offset;
      D.30163 = D.30161 - D.30162;
      hole->length = D.30163;
      D.29996 = cfg->verbose_level;
      D.29997 = D.29996 > 3;
      D.29998 = (long int) D.29997;
      D.29999 = __builtin_expect (D.29998, 0);
      if (D.29999 != 0) goto <D.30164>; else goto <D.30165>;
      <D.30164>:
      D.30166 = hole->length;
      D.30167 = (int) D.30166;
      D.30168 = hole->offset;
      D.30169 = hole->clause;
      D.30170 = (int) D.30169;
      printf ("\tTry block hole at eh clause %d offset %x length %x\n", D.30170, D.30168, D.30167);
      <D.30165>:
    }
    <D.25874>:
    tmp = tmp->next;
    <D.25876>:
    if (tmp != 0B) goto <D.25875>; else goto <D.25877>;
    <D.25877>:
    D.30171 = i != num_holes;
    D.30172 = (long int) D.30171;
    D.30173 = __builtin_expect (D.30172, 0);
    if (D.30173 != 0) goto <D.30174>; else goto <D.30175>;
    <D.30174>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4455, "i == num_holes");
    <D.30175>:
  }
  <D.30132>:
  if (arch_eh_info_size != 0) goto <D.30176>; else goto <D.30177>;
  <D.30176>:
  {
    struct MonoArchEHJitInfo * info;

    jinfo->has_arch_eh_info = -1;
    info = mono_jit_info_get_arch_eh_info (jinfo);
    info->stack_size = stack_size;
  }
  <D.30177>:
  if (cas_size != 0) goto <D.30178>; else goto <D.30179>;
  <D.30178>:
  jinfo->has_cas_info = -1;
  <D.30179>:
  if (0 != 0) goto <D.30180>; else goto <D.30181>;
  <D.30180>:
  if (num_clauses != 0) goto <D.30182>; else goto <D.30183>;
  <D.30182>:
  num_clauses.137 = (unsigned int) num_clauses;
  D.30015 = num_clauses.137 * 24;
  D.30184 = cfg->llvm_ex_info;
  D.30185 = &jinfo->clauses[0];
  memcpy (D.30185, D.30184, D.30015);
  <D.30183>:
  goto <D.30186>;
  <D.30181>:
  D.30187 = BIT_FIELD_REF <*header, 16, 80>;
  D.30188 = D.30187 & 32767;
  if (D.30188 != 0) goto <D.30189>; else goto <D.30190>;
  <D.30189>:
  {
    int i;

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

      D.30155 = header->clauses;
      i.144 = (unsigned int) i;
      D.30192 = i.144 * 24;
      ec = D.30155 + D.30192;
      ei = &jinfo->clauses[i];
      D.30193 = ec->flags;
      ei->flags = D.30193;
      D.30194 = ec->handler_offset;
      D.30195 = (int) D.30194;
      exvar = mono_find_exvar_for_offset (cfg, D.30195);
      if (exvar != 0B) goto <D.30197>; else goto <D.30198>;
      <D.30197>:
      iftmp.145 = exvar->data.op[0].const_val;
      goto <D.30199>;
      <D.30198>:
      iftmp.145 = 0;
      <D.30199>:
      ei->exvar_offset = iftmp.145;
      D.30200 = ei->flags;
      if (D.30200 == 1) goto <D.30201>; else goto <D.30202>;
      <D.30201>:
      D.29977 = cfg->cil_offset_to_bb;
      D.30203 = ec->data.filter_offset;
      D.30204 = D.30203 * 4;
      D.30205 = D.29977 + D.30204;
      tblock = *D.30205;
      D.30206 = tblock == 0B;
      D.30207 = (long int) D.30206;
      D.30208 = __builtin_expect (D.30207, 0);
      if (D.30208 != 0) goto <D.30209>; else goto <D.30210>;
      <D.30209>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4490, "tblock");
      <D.30210>:
      D.30027 = cfg->native_code;
      D.30211 = tblock->native_offset;
      D.30212 = (sizetype) D.30211;
      D.30213 = D.30027 + D.30212;
      ei->data.filter = D.30213;
      goto <D.30214>;
      <D.30202>:
      D.30215 = ec->data.catch_class;
      ei->data.catch_class = D.30215;
      <D.30214>:
      D.29977 = cfg->cil_offset_to_bb;
      D.30216 = ec->try_offset;
      D.30217 = D.30216 * 4;
      D.30218 = D.29977 + D.30217;
      tblock = *D.30218;
      D.30206 = tblock == 0B;
      D.30207 = (long int) D.30206;
      D.30208 = __builtin_expect (D.30207, 0);
      if (D.30208 != 0) goto <D.30219>; else goto <D.30220>;
      <D.30219>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4497, "tblock");
      <D.30220>:
      D.30211 = tblock->native_offset;
      D.30221 = D.30211 == 0;
      D.30222 = (long int) D.30221;
      D.30223 = __builtin_expect (D.30222, 0);
      if (D.30223 != 0) goto <D.30224>; else goto <D.30225>;
      <D.30224>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4498, "tblock->native_offset");
      <D.30225>:
      D.30027 = cfg->native_code;
      D.30211 = tblock->native_offset;
      D.30212 = (sizetype) D.30211;
      D.30213 = D.30027 + D.30212;
      ei->try_start = D.30213;
      D.30226 = BIT_FIELD_REF <*tblock, 8, 912>;
      D.30227 = D.30226 & 128;
      if (D.30227 != 0) goto <D.30228>; else goto <D.30229>;
      <D.30228>:
      D.30230 = ei->try_start;
      D.30231 = D.30230 + 4294967292;
      ei->try_start = D.30231;
      <D.30229>:
      D.29977 = cfg->cil_offset_to_bb;
      D.30216 = ec->try_offset;
      D.30232 = ec->try_len;
      D.30233 = D.30216 + D.30232;
      D.30234 = D.30233 * 4;
      D.30235 = D.29977 + D.30234;
      tblock = *D.30235;
      D.30206 = tblock == 0B;
      D.30207 = (long int) D.30206;
      D.30208 = __builtin_expect (D.30207, 0);
      if (D.30208 != 0) goto <D.30236>; else goto <D.30237>;
      <D.30236>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4508, "tblock");
      <D.30237>:
      D.30211 = tblock->native_offset;
      if (D.30211 == 0) goto <D.30238>; else goto <D.30239>;
      <D.30238>:
      {
        int j;
        int end;

        D.30216 = ec->try_offset;
        D.30232 = ec->try_len;
        D.30233 = D.30216 + D.30232;
        j = (int) D.30233;
        D.30216 = ec->try_offset;
        end = (int) D.30216;
        goto <D.25889>;
        <D.25888>:
        {
          struct MonoBasicBlock * bb;

          D.29977 = cfg->cil_offset_to_bb;
          j.146 = (unsigned int) j;
          D.30241 = j.146 * 4;
          D.30242 = D.29977 + D.30241;
          bb = *D.30242;
          if (bb != 0B) goto <D.30243>; else goto <D.30244>;
          <D.30243>:
          D.30245 = bb->native_offset;
          if (D.30245 != 0) goto <D.30246>; else goto <D.30247>;
          <D.30246>:
          tblock = bb;
          goto <D.25887>;
          <D.30247>:
          <D.30244>:
        }
        j = j + -1;
        <D.25889>:
        if (j >= end) goto <D.25888>; else goto <D.25887>;
        <D.25887>:
      }
      <D.30239>:
      D.30027 = cfg->native_code;
      D.30211 = tblock->native_offset;
      D.30212 = (sizetype) D.30211;
      D.30213 = D.30027 + D.30212;
      ei->try_end = D.30213;
      D.30211 = tblock->native_offset;
      D.30221 = D.30211 == 0;
      D.30222 = (long int) D.30221;
      D.30223 = __builtin_expect (D.30222, 0);
      if (D.30223 != 0) goto <D.30248>; else goto <D.30249>;
      <D.30248>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4520, "tblock->native_offset");
      <D.30249>:
      D.29977 = cfg->cil_offset_to_bb;
      D.30194 = ec->handler_offset;
      D.30250 = D.30194 * 4;
      D.30251 = D.29977 + D.30250;
      tblock = *D.30251;
      D.30206 = tblock == 0B;
      D.30207 = (long int) D.30206;
      D.30208 = __builtin_expect (D.30207, 0);
      if (D.30208 != 0) goto <D.30252>; else goto <D.30253>;
      <D.30252>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4522, "tblock");
      <D.30253>:
      D.30027 = cfg->native_code;
      D.30211 = tblock->native_offset;
      D.30212 = (sizetype) D.30211;
      D.30213 = D.30027 + D.30212;
      ei->handler_start = D.30213;
      tmp = cfg->try_block_holes;
      goto <D.25894>;
      <D.25893>:
      {
        struct TryBlockHole * hole;
        void * hole_end;

        hole = tmp->data;
        D.30027 = cfg->native_code;
        D.30254 = hole->basic_block;
        D.30255 = D.30254->native_offset;
        D.30254 = hole->basic_block;
        D.30256 = D.30254->native_length;
        D.30257 = D.30255 + D.30256;
        D.30258 = (sizetype) D.30257;
        hole_end = D.30027 + D.30258;
        D.30259 = hole->clause;
        if (D.30259 == ec) goto <D.30260>; else goto <D.30261>;
        <D.30260>:
        D.30262 = ei->try_end;
        if (D.30262 == hole_end) goto <D.30263>; else goto <D.30264>;
        <D.30263>:
        D.29996 = cfg->verbose_level;
        D.29997 = D.29996 > 3;
        D.29998 = (long int) D.29997;
        D.29999 = __builtin_expect (D.29998, 0);
        if (D.29999 != 0) goto <D.30265>; else goto <D.30266>;
        <D.30265>:
        D.30267 = hole->start_offset;
        D.30262 = ei->try_end;
        D.30268 = (int) D.30262;
        D.30027 = cfg->native_code;
        D.30269 = (int) D.30027;
        D.30270 = D.30268 - D.30269;
        printf ("\tShortening try block %d from %x to %x\n", i, D.30270, D.30267);
        <D.30266>:
        D.30027 = cfg->native_code;
        D.30267 = hole->start_offset;
        D.30271 = (sizetype) D.30267;
        D.30272 = D.30027 + D.30271;
        ei->try_end = D.30272;
        goto <D.25892>;
        <D.30264>:
        <D.30261>:
      }
      tmp = tmp->next;
      <D.25894>:
      if (tmp != 0B) goto <D.25893>; else goto <D.25892>;
      <D.25892>:
      D.30193 = ec->flags;
      if (D.30193 == 2) goto <D.30273>; else goto <D.30274>;
      <D.30273>:
      {
        int end_offset;

        D.30194 = ec->handler_offset;
        D.30275 = ec->handler_len;
        D.30276 = D.30194 + D.30275;
        D.30277 = header->code_size;
        if (D.30276 < D.30277) goto <D.30278>; else goto <D.30279>;
        <D.30278>:
        D.29977 = cfg->cil_offset_to_bb;
        D.30194 = ec->handler_offset;
        D.30275 = ec->handler_len;
        D.30276 = D.30194 + D.30275;
        D.30280 = D.30276 * 4;
        D.30281 = D.29977 + D.30280;
        tblock = *D.30281;
        D.30211 = tblock->native_offset;
        if (D.30211 != 0) goto <D.30282>; else goto <D.30283>;
        <D.30282>:
        end_offset = tblock->native_offset;
        goto <D.30284>;
        <D.30283>:
        {
          int j;
          int end;

          D.30194 = ec->handler_offset;
          D.30275 = ec->handler_len;
          D.30276 = D.30194 + D.30275;
          j = (int) D.30276;
          D.30194 = ec->handler_offset;
          end = (int) D.30194;
          goto <D.25901>;
          <D.25900>:
          {
            struct MonoBasicBlock * bb;

            D.29977 = cfg->cil_offset_to_bb;
            j.147 = (unsigned int) j;
            D.30286 = j.147 * 4;
            D.30287 = D.29977 + D.30286;
            bb = *D.30287;
            if (bb != 0B) goto <D.30288>; else goto <D.30289>;
            <D.30288>:
            D.30290 = bb->native_offset;
            if (D.30290 != 0) goto <D.30291>; else goto <D.30292>;
            <D.30291>:
            tblock = bb;
            goto <D.25899>;
            <D.30292>:
            <D.30289>:
          }
          j = j + -1;
          <D.25901>:
          if (j >= end) goto <D.25900>; else goto <D.25899>;
          <D.25899>:
          D.30211 = tblock->native_offset;
          D.30293 = tblock->native_length;
          end_offset = D.30211 + D.30293;
        }
        <D.30284>:
        goto <D.30294>;
        <D.30279>:
        D.30295 = cfg->epilog_begin;
        end_offset = (int) D.30295;
        <D.30294>:
        D.30027 = cfg->native_code;
        end_offset.148 = (sizetype) end_offset;
        D.30297 = D.30027 + end_offset.148;
        ei->data.handler_end = D.30297;
      }
      <D.30274>:
    }
    i = i + 1;
    <D.25903>:
    D.30009 = header->num_clauses;
    D.30298 = (int) D.30009;
    if (D.30298 > i) goto <D.25902>; else goto <D.25904>;
    <D.25904>:
  }
  <D.30190>:
  <D.30186>:
  D.29996 = cfg->verbose_level;
  D.29997 = D.29996 > 3;
  D.29998 = (long int) D.29997;
  D.29999 = __builtin_expect (D.29998, 0);
  if (D.29999 != 0) goto <D.30299>; else goto <D.30300>;
  <D.30299>:
  {
    int i;

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

      ei = &jinfo->clauses[i];
      D.30301 = ei->try_start;
      D.30302 = (int) D.30301;
      D.30027 = cfg->native_code;
      D.30269 = (int) D.30027;
      start = D.30302 - D.30269;
      D.30303 = ei->try_end;
      D.30304 = (int) D.30303;
      D.30027 = cfg->native_code;
      D.30269 = (int) D.30027;
      end = D.30304 - D.30269;
      D.30305 = ei->handler_start;
      D.30306 = (int) D.30305;
      D.30027 = cfg->native_code;
      D.30269 = (int) D.30027;
      handler = D.30306 - D.30269;
      D.30307 = ei->data.handler_end;
      D.30308 = (int) D.30307;
      D.30027 = cfg->native_code;
      D.30269 = (int) D.30027;
      handler_end = D.30308 - D.30269;
      D.30309 = ei->flags;
      printf ("JitInfo EH clause %d flags %x try %x-%x handler %x-%x\n", i, D.30309, start, end, handler, handler_end);
    }
    i = i + 1;
    <D.25912>:
    D.30310 = jinfo->num_clauses;
    D.30311 = (int) D.30310;
    if (D.30311 > i) goto <D.25911>; else goto <D.25913>;
    <D.25913>:
  }
  <D.30300>:
  D.30312 = cfg->encoded_unwind_ops;
  if (D.30312 != 0B) goto <D.30313>; else goto <D.30314>;
  <D.30313>:
  D.30315 = cfg->encoded_unwind_ops_len;
  D.30312 = cfg->encoded_unwind_ops;
  D.30316 = mono_cache_unwind_info (D.30312, D.30315);
  jinfo->used_regs = D.30316;
  D.30312 = cfg->encoded_unwind_ops;
  monoeg_g_free (D.30312);
  goto <D.30317>;
  <D.30314>:
  D.30318 = cfg->unwind_ops;
  if (D.30318 != 0B) goto <D.30319>; else goto <D.30320>;
  <D.30319>:
  {
    guint32 info_len;
    guint8 * unwind_info;

    try
      {
        D.30318 = cfg->unwind_ops;
        unwind_info = mono_unwind_ops_encode (D.30318, &info_len);
        info_len.149 = info_len;
        D.30322 = mono_cache_unwind_info (unwind_info, info_len.149);
        jinfo->used_regs = D.30322;
        monoeg_g_free (unwind_info);
      }
    finally
      {
        info_len = {CLOBBER};
      }
  }
  <D.30320>:
  <D.30317>:
  D.30323 = jinfo;
  return D.30323;
}


mono_save_seq_point_info (struct MonoCompile * cfg)
{
  struct GPtrArray * D.30325;
  unsigned int D.30328;
  unsigned int D.30329;
  unsigned int D.30330;
  int D.30331;
  void * * D.30332;
  unsigned int i.150;
  unsigned int D.30334;
  void * * D.30335;
  int D.30336;
  int D.30337;
  unsigned char D.30338;
  int D.30339;
  int D.30340;
  int D.30343;
  int D.30344;
  unsigned int i.151;
  unsigned int D.30346;
  struct GSList * D.30347;
  int D.30348;
  _Bool D.30349;
  _Bool D.30350;
  _Bool D.30351;
  int D.30354;
  int D.30359;
  unsigned int D.30360;
  unsigned int D.30361;
  struct GSList * * D.30362;
  int D.30363;
  void * D.30364;
  struct GSList * D.30365;
  struct GSList * D.30366;
  struct MonoInst * D.30368;
  short unsigned int D.30371;
  struct GSList * D.30378;
  int D.30381;
  _Bool D.30382;
  _Bool D.30383;
  _Bool D.30384;
  int D.30389;
  unsigned int D.30390;
  unsigned int D.30391;
  struct GSList * * D.30392;
  int D.30393;
  void * D.30394;
  struct GSList * D.30395;
  struct GSList * D.30396;
  unsigned int D.30397;
  struct GSList * * D.30400;
  struct GSList * D.30401;
  unsigned int D.30402;
  int D.30403;
  int D.30404;
  unsigned int D.30405;
  unsigned int D.30406;
  void * D.30407;
  int D.30412;
  void * D.30413;
  int D.30414;
  int * D.30415;
  int j.152;
  unsigned int j.153;
  unsigned int D.30418;
  int * D.30419;
  unsigned char D.30420;
  unsigned char D.30421;
  union mono_mutex_t * D.30424;
  _Bool D.30427;
  long int D.30428;
  long int D.30429;
  struct MonoMethod * D.30432;
  void * D.30433;
  struct GHashTable * D.30434;
  void * D.30435;
  _Bool D.30440;
  long int D.30441;
  long int D.30442;
  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.30325 = cfg->seq_points;
  if (D.30325 == 0B) goto <D.30326>; else goto <D.30327>;
  <D.30326>:
  return;
  <D.30327>:
  D.30325 = cfg->seq_points;
  D.30328 = D.30325->len;
  D.30329 = D.30328 * 20;
  D.30330 = D.30329 + 4;
  info = monoeg_malloc0 (D.30330);
  D.30325 = cfg->seq_points;
  D.30328 = D.30325->len;
  D.30331 = (int) D.30328;
  info->len = D.30331;
  i = 0;
  goto <D.25761>;
  <D.25760>:
  {
    struct SeqPoint * sp;
    struct MonoInst * ins;

    sp = &info->seq_points[i];
    D.30325 = cfg->seq_points;
    D.30332 = D.30325->pdata;
    i.150 = (unsigned int) i;
    D.30334 = i.150 * 4;
    D.30335 = D.30332 + D.30334;
    ins = *D.30335;
    D.30336 = ins->data.op[1].const_val;
    sp->il_offset = D.30336;
    D.30337 = ins->data.op[0].const_val;
    sp->native_offset = D.30337;
    D.30338 = ins->flags;
    D.30339 = (int) D.30338;
    D.30340 = D.30339 & 4;
    if (D.30340 != 0) goto <D.30341>; else goto <D.30342>;
    <D.30341>:
    D.30343 = sp->flags;
    D.30344 = D.30343 | 1;
    sp->flags = D.30344;
    <D.30342>:
    ins->backend.size = i;
  }
  i = i + 1;
  <D.25761>:
  i.151 = (unsigned int) i;
  D.30325 = cfg->seq_points;
  D.30328 = D.30325->len;
  if (i.151 < D.30328) goto <D.25760>; else goto <D.25762>;
  <D.25762>:
  D.30325 = cfg->seq_points;
  D.30328 = D.30325->len;
  D.30346 = D.30328 * 4;
  next = monoeg_malloc0 (D.30346);
  bb = cfg->bb_entry;
  goto <D.25776>;
  <D.25775>:
  D.30347 = bb->seq_points;
  bb_seq_points = monoeg_g_slist_reverse (D.30347);
  last = 0B;
  l = bb_seq_points;
  goto <D.25766>;
  <D.25765>:
  {
    struct MonoInst * ins;

    ins = l->data;
    D.30348 = ins->data.op[1].const_val;
    D.30349 = D.30348 == -1;
    D.30350 = D.30348 == 16777215;
    D.30351 = D.30349 | D.30350;
    if (D.30351 != 0) goto <D.30352>; else goto <D.30353>;
    <D.30352>:
    // predicted unlikely by continue predictor.
    goto <D.25764>;
    <D.30353>:
    D.30354 = ins->data.op[0].const_val;
    if (D.30354 == -1) goto <D.30355>; else goto <D.30356>;
    <D.30355>:
    // predicted unlikely by continue predictor.
    goto <D.25764>;
    <D.30356>:
    if (last != 0B) goto <D.30357>; else goto <D.30358>;
    <D.30357>:
    D.30359 = last->backend.size;
    D.30360 = (unsigned int) D.30359;
    D.30361 = D.30360 * 4;
    D.30362 = next + D.30361;
    D.30363 = ins->backend.size;
    D.30364 = (void *) D.30363;
    D.30359 = last->backend.size;
    D.30360 = (unsigned int) D.30359;
    D.30361 = D.30360 * 4;
    D.30362 = next + D.30361;
    D.30365 = *D.30362;
    D.30366 = monoeg_g_slist_append (D.30365, D.30364);
    *D.30362 = D.30366;
    goto <D.30367>;
    <D.30358>:
    collect_pred_seq_points (bb, ins, next, 0);
    <D.30367>:
    last = ins;
  }
  <D.25764>:
  l = l->next;
  <D.25766>:
  if (l != 0B) goto <D.25765>; else goto <D.25767>;
  <D.25767>:
  D.30368 = bb->last_ins;
  if (D.30368 != 0B) goto <D.30369>; else goto <D.30370>;
  <D.30369>:
  D.30368 = bb->last_ins;
  D.30371 = D.30368->opcode;
  if (D.30371 == 742) goto <D.30372>; else goto <D.30373>;
  <D.30372>:
  D.30347 = bb->seq_points;
  if (D.30347 != 0B) goto <D.30374>; else goto <D.30375>;
  <D.30374>:
  {
    struct MonoBasicBlock * bb2;
    struct MonoInst * endfinally_seq_point;

    endfinally_seq_point = 0B;
    D.30347 = bb->seq_points;
    l = monoeg_g_slist_last (D.30347);
    if (l != 0B) goto <D.30376>; else goto <D.30377>;
    <D.30376>:
    endfinally_seq_point = l->data;
    bb2 = cfg->bb_entry;
    goto <D.25773>;
    <D.25772>:
    {
      struct GSList * l;

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

        ins = l->data;
        D.30381 = ins->data.op[1].const_val;
        D.30382 = D.30381 != -1;
        D.30383 = D.30381 != 16777215;
        D.30384 = D.30382 & D.30383;
        if (D.30384 != 0) goto <D.30385>; else goto <D.30386>;
        <D.30385>:
        if (ins != endfinally_seq_point) goto <D.30387>; else goto <D.30388>;
        <D.30387>:
        D.30389 = endfinally_seq_point->backend.size;
        D.30390 = (unsigned int) D.30389;
        D.30391 = D.30390 * 4;
        D.30392 = next + D.30391;
        D.30393 = ins->backend.size;
        D.30394 = (void *) D.30393;
        D.30389 = endfinally_seq_point->backend.size;
        D.30390 = (unsigned int) D.30389;
        D.30391 = D.30390 * 4;
        D.30392 = next + D.30391;
        D.30395 = *D.30392;
        D.30396 = monoeg_g_slist_append (D.30395, D.30394);
        *D.30392 = D.30396;
        <D.30388>:
        <D.30386>:
      }
      <D.30380>:
    }
    bb2 = bb2->next_bb;
    <D.25773>:
    if (bb2 != 0B) goto <D.25772>; else goto <D.25774>;
    <D.25774>:
    <D.30377>:
  }
  <D.30375>:
  <D.30373>:
  <D.30370>:
  bb = bb->next_bb;
  <D.25776>:
  if (bb != 0B) goto <D.25775>; else goto <D.25777>;
  <D.25777>:
  D.30397 = cfg->verbose_level;
  if (D.30397 > 2) goto <D.30398>; else goto <D.30399>;
  <D.30398>:
  printf ("\nSEQ POINT MAP: \n");
  <D.30399>:
  i = 0;
  goto <D.25789>;
  <D.25788>:
  {
    struct SeqPoint * sp;
    struct GSList * l;
    int j;
    int next_index;

    sp = &info->seq_points[i];
    i.150 = (unsigned int) i;
    D.30334 = i.150 * 4;
    D.30400 = next + D.30334;
    D.30401 = *D.30400;
    D.30402 = monoeg_g_slist_length (D.30401);
    D.30403 = (int) D.30402;
    sp->next_len = D.30403;
    D.30404 = sp->next_len;
    D.30405 = (unsigned int) D.30404;
    D.30406 = D.30405 * 4;
    D.30407 = monoeg_malloc (D.30406);
    sp->next = D.30407;
    j = 0;
    D.30397 = cfg->verbose_level;
    if (D.30397 > 2) goto <D.30408>; else goto <D.30409>;
    <D.30408>:
    i.150 = (unsigned int) i;
    D.30334 = i.150 * 4;
    D.30400 = next + D.30334;
    D.30401 = *D.30400;
    if (D.30401 != 0B) goto <D.30410>; else goto <D.30411>;
    <D.30410>:
    D.30412 = sp->il_offset;
    printf ("\tIL0x%x ->", D.30412);
    i.150 = (unsigned int) i;
    D.30334 = i.150 * 4;
    D.30400 = next + D.30334;
    l = *D.30400;
    goto <D.25783>;
    <D.25782>:
    D.30413 = l->data;
    next_index = (int) D.30413;
    D.30414 = info->seq_points[next_index].il_offset;
    printf (" IL0x%x", D.30414);
    l = l->next;
    <D.25783>:
    if (l != 0B) goto <D.25782>; else goto <D.25784>;
    <D.25784>:
    printf ("\n");
    <D.30411>:
    <D.30409>:
    i.150 = (unsigned int) i;
    D.30334 = i.150 * 4;
    D.30400 = next + D.30334;
    l = *D.30400;
    goto <D.25786>;
    <D.25785>:
    D.30413 = l->data;
    next_index = (int) D.30413;
    D.30415 = sp->next;
    j.152 = j;
    j = j.152 + 1;
    j.153 = (unsigned int) j.152;
    D.30418 = j.153 * 4;
    D.30419 = D.30415 + D.30418;
    *D.30419 = next_index;
    l = l->next;
    <D.25786>:
    if (l != 0B) goto <D.25785>; else goto <D.25787>;
    <D.25787>:
    i.150 = (unsigned int) i;
    D.30334 = i.150 * 4;
    D.30400 = next + D.30334;
    D.30401 = *D.30400;
    monoeg_g_slist_free (D.30401);
  }
  i = i + 1;
  <D.25789>:
  i.151 = (unsigned int) i;
  D.30325 = cfg->seq_points;
  D.30328 = D.30325->len;
  if (i.151 < D.30328) goto <D.25788>; else goto <D.25790>;
  <D.25790>:
  monoeg_g_free (next);
  cfg->seq_point_info = info;
  D.30420 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.30421 = D.30420 & 64;
  if (D.30421 == 0) goto <D.30422>; else goto <D.30423>;
  <D.30422>:
  {
    int ret;

    D.30424 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.30424);
    if (ret != 0) goto <D.30425>; else goto <D.30426>;
    <D.30425>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30426>:
    D.30427 = ret != 0;
    D.30428 = (long int) D.30427;
    D.30429 = __builtin_expect (D.30428, 0);
    if (D.30429 != 0) goto <D.30430>; else goto <D.30431>;
    <D.30430>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3994, "ret == 0");
    <D.30431>:
  }
  D.30432 = cfg->method_to_register;
  D.30433 = domain->runtime_info;
  D.30434 = MEM[(struct MonoJitDomainInfo *)D.30433].seq_points;
  D.30435 = monoeg_g_hash_table_lookup (D.30434, D.30432);
  if (D.30435 == 0B) goto <D.30436>; else goto <D.30437>;
  <D.30436>:
  D.30432 = cfg->method_to_register;
  D.30433 = domain->runtime_info;
  D.30434 = MEM[(struct MonoJitDomainInfo *)D.30433].seq_points;
  monoeg_g_hash_table_insert_replace (D.30434, D.30432, info, 0);
  <D.30437>:
  {
    int ret;

    D.30424 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30424);
    if (ret != 0) goto <D.30438>; else goto <D.30439>;
    <D.30438>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30439>:
    D.30440 = ret != 0;
    D.30441 = (long int) D.30440;
    D.30442 = __builtin_expect (D.30441, 0);
    if (D.30442 != 0) goto <D.30443>; else goto <D.30444>;
    <D.30443>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3998, "ret == 0");
    <D.30444>:
  }
  <D.30423>:
  D.30325 = cfg->seq_points;
  monoeg_g_ptr_array_free (D.30325, 1);
  cfg->seq_points = 0B;
}


collect_pred_seq_points (struct MonoBasicBlock * bb, struct MonoInst * ins, struct GSList * * next, int depth)
{
  struct MonoBasicBlock * * D.30446;
  unsigned int i.154;
  unsigned int D.30448;
  struct MonoBasicBlock * * D.30449;
  struct MonoInst * D.30450;
  unsigned int src_index.155;
  unsigned int D.30454;
  struct GSList * * D.30455;
  void * D.30456;
  unsigned int D.30457;
  unsigned int dst_index.156;
  void * dst_index.157;
  struct GSList * D.30463;
  struct GSList * D.30464;
  int D.30468;
  short int D.30469;
  int D.30470;
  int i;
  struct MonoBasicBlock * in_bb;
  struct GSList * l;

  i = 0;
  goto <D.25745>;
  <D.25744>:
  D.30446 = bb->in_bb;
  i.154 = (unsigned int) i;
  D.30448 = i.154 * 4;
  D.30449 = D.30446 + D.30448;
  in_bb = *D.30449;
  D.30450 = in_bb->last_seq_point;
  if (D.30450 != 0B) goto <D.30451>; else goto <D.30452>;
  <D.30451>:
  {
    int src_index;
    int dst_index;

    D.30450 = in_bb->last_seq_point;
    src_index = D.30450->backend.size;
    dst_index = ins->backend.size;
    src_index.155 = (unsigned int) src_index;
    D.30454 = src_index.155 * 4;
    D.30455 = next + D.30454;
    l = *D.30455;
    goto <D.25743>;
    <D.25742>:
    D.30456 = l->data;
    D.30457 = (unsigned int) D.30456;
    dst_index.156 = (unsigned int) dst_index;
    if (D.30457 == dst_index.156) goto <D.25741>; else goto <D.30459>;
    <D.30459>:
    l = l->next;
    <D.25743>:
    if (l != 0B) goto <D.25742>; else goto <D.25741>;
    <D.25741>:
    if (l == 0B) goto <D.30460>; else goto <D.30461>;
    <D.30460>:
    src_index.155 = (unsigned int) src_index;
    D.30454 = src_index.155 * 4;
    D.30455 = next + D.30454;
    dst_index.157 = (void *) dst_index;
    src_index.155 = (unsigned int) src_index;
    D.30454 = src_index.155 * 4;
    D.30455 = next + D.30454;
    D.30463 = *D.30455;
    D.30464 = monoeg_g_slist_append (D.30463, dst_index.157);
    *D.30455 = D.30464;
    <D.30461>:
  }
  goto <D.30465>;
  <D.30452>:
  if (depth <= 4) goto <D.30466>; else goto <D.30467>;
  <D.30466>:
  D.30468 = depth + 1;
  collect_pred_seq_points (in_bb, ins, next, D.30468);
  <D.30467>:
  <D.30465>:
  i = i + 1;
  <D.25745>:
  D.30469 = bb->in_count;
  D.30470 = (int) D.30469;
  if (D.30470 > i) goto <D.25744>; else goto <D.25746>;
  <D.25746>:
}


mono_domain_lookup_shared_generic (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoMethod * D.30471;
  struct MonoInternalHashTable * D.30472;
  unsigned char D.30475;
  unsigned char D.30476;
  int inited.158;
  int lookups.159;
  int lookups.160;
  int failed_lookups.161;
  int failed_lookups.162;
  struct MonoJitInfo * D.30488;
  static gboolean inited = 0;
  static int lookups = 0;
  static int failed_lookups = 0;
  struct MonoJitInfo * ji;

  D.30471 = mini_get_shared_method (method);
  D.30472 = &domain->jit_code_hash;
  ji = mono_internal_hash_table_lookup (D.30472, D.30471);
  if (ji != 0B) goto <D.30473>; else goto <D.30474>;
  <D.30473>:
  D.30475 = BIT_FIELD_REF <*ji, 8, 176>;
  D.30476 = D.30475 & 2;
  if (D.30476 == 0) goto <D.30477>; else goto <D.30478>;
  <D.30477>:
  ji = 0B;
  <D.30478>:
  <D.30474>:
  inited.158 = inited;
  if (inited.158 == 0) goto <D.30480>; else goto <D.30481>;
  <D.30480>:
  mono_counters_register ("Shared generic lookups", 2048, &lookups);
  mono_counters_register ("Failed shared generic lookups", 2048, &failed_lookups);
  inited = 1;
  <D.30481>:
  lookups.159 = lookups;
  lookups.160 = lookups.159 + 1;
  lookups = lookups.160;
  if (ji == 0B) goto <D.30484>; else goto <D.30485>;
  <D.30484>:
  failed_lookups.161 = failed_lookups;
  failed_lookups.162 = failed_lookups.161 + 1;
  failed_lookups = failed_lookups.162;
  <D.30485>:
  D.30488 = ji;
  return D.30488;
}


mono_enable_jit_map ()
{
  struct FILE * perf_map_file.163;
  int D.30493;
  struct FILE * perf_map_file.164;

  perf_map_file.163 = perf_map_file;
  if (perf_map_file.163 == 0B) goto <D.30491>; else goto <D.30492>;
  <D.30491>:
  {
    char name[64];

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


mono_emit_jit_tramp (void * start, int size, const char * desc)
{
  struct FILE * perf_map_file.165;
  unsigned int start.166;
  long long unsigned int D.30499;

  perf_map_file.165 = perf_map_file;
  if (perf_map_file.165 != 0B) goto <D.30496>; else goto <D.30497>;
  <D.30496>:
  start.166 = (unsigned int) start;
  D.30499 = (long long unsigned int) start.166;
  perf_map_file.165 = perf_map_file;
  fprintf (perf_map_file.165, "%llx %x %s\n", D.30499, size, desc);
  <D.30497>:
}


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

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


mono_emit_jit_map (struct MonoJitInfo * jinfo)
{
  struct FILE * perf_map_file.167;
  struct MonoMethod * D.30505;
  int D.30506;
  void * D.30507;

  perf_map_file.167 = perf_map_file;
  if (perf_map_file.167 != 0B) goto <D.30503>; else goto <D.30504>;
  <D.30503>:
  {
    char * name;

    D.30505 = jinfo_get_method (jinfo);
    name = mono_method_full_name (D.30505, 1);
    D.30506 = jinfo->code_size;
    D.30507 = jinfo->code_start;
    mono_emit_jit_tramp (D.30507, D.30506, name);
    monoeg_g_free (name);
  }
  <D.30504>:
}


mono_jit_map_is_enabled ()
{
  gboolean D.30508;
  struct FILE * perf_map_file.168;
  _Bool D.30510;

  perf_map_file.168 = perf_map_file;
  D.30510 = perf_map_file.168 != 0B;
  D.30508 = (gboolean) D.30510;
  return D.30508;
}


mono_jit_compile_method (struct MonoMethod * method)
{
  unsigned int default_opt.169;
  unsigned int D.30513;
  struct MonoException * ex.170;
  _Bool D.30517;
  long int D.30518;
  long int D.30519;
  void * D.30522;
  struct MonoException * ex;
  void * code;

  try
    {
      ex = 0B;
      default_opt.169 = default_opt;
      D.30513 = mono_get_optimizations_for_method (method, default_opt.169);
      code = mono_jit_compile_method_with_opt (method, D.30513, &ex);
      if (code == 0B) goto <D.30514>; else goto <D.30515>;
      <D.30514>:
      ex.170 = ex;
      D.30517 = ex.170 == 0B;
      D.30518 = (long int) D.30517;
      D.30519 = __builtin_expect (D.30518, 0);
      if (D.30519 != 0) goto <D.30520>; else goto <D.30521>;
      <D.30520>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6250, "ex");
      <D.30521>:
      ex.170 = ex;
      mono_raise_exception (ex.170);
      <D.30515>:
      D.30522 = code;
      return D.30522;
    }
  finally
    {
      ex = {CLOBBER};
    }
}


mono_jit_compile_method_with_opt (struct MonoMethod * method, guint32 opt, struct MonoException * * ex)
{
  unsigned char D.30525;
  unsigned char D.30526;
  <unnamed type> D.30531;
  void * D.30534;
  _Bool D.30535;
  long int D.30536;
  long int D.30537;
  unsigned char D.30540;
  unsigned char D.30541;
  struct MonoClass * D.30546;
  struct MonoImage * D.30547;
  struct MonoImage * D.30548;
  unsigned char D.30550;
  unsigned int D.30551;
  _Bool D.30557;
  long int D.30558;
  long int D.30559;
  <unnamed type> D.30562;
  unsigned char D.30574;
  unsigned char D.30575;
  int D.30576;
  int D.30577;
  _Bool D.30578;
  long int D.30579;
  long int D.30580;
  _Bool D.30583;
  int D.30584;
  void * D.30587;
  void * D.30588;
  int opt.171;
  unsigned char D.30592;
  _Bool D.30593;
  _Bool D.30594;
  _Bool D.30595;
  struct MonoDomain * D.30598;
  _Bool D.30599;
  long int D.30600;
  long int D.30601;
  _Bool D.30608;
  long int D.30609;
  long int D.30610;
  const void * D.30613;
  _Bool D.30618;
  long int D.30619;
  long int D.30620;
  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.30525 = BIT_FIELD_REF <*method, 8, 160>;
  D.30526 = D.30525 & 124;
  if (D.30526 == 24) goto <D.30527>; else goto <D.30528>;
  <D.30527>:
  winfo = mono_marshal_get_wrapper_info (method);
  <D.30528>:
  if (winfo != 0B) goto <D.30529>; else goto <D.30530>;
  <D.30529>:
  D.30531 = winfo->subtype;
  if (D.30531 == 15) goto <D.30532>; else goto <D.30533>;
  <D.30532>:
  D.30534 = winfo->d.icall.func;
  callinfo = mono_find_jit_icall_by_addr (D.30534);
  D.30535 = callinfo == 0B;
  D.30536 = (long int) D.30535;
  D.30537 = __builtin_expect (D.30536, 0);
  if (D.30537 != 0) goto <D.30538>; else goto <D.30539>;
  <D.30538>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6160, "callinfo");
  <D.30539>:
  opt = opt | 512;
  <D.30533>:
  <D.30530>:
  D.30540 = BIT_FIELD_REF <*method, 8, 168>;
  D.30541 = D.30540 & 2;
  if (D.30541 != 0) goto <D.30542>; else goto <D.30543>;
  <D.30542>:
  opt = opt & 4294966783;
  <D.30543>:
  D.30546 = method->klass;
  D.30547 = D.30546->image;
  D.30548 = mono_get_corlib ();
  if (D.30547 != D.30548) goto <D.30544>; else goto <D.30549>;
  <D.30549>:
  D.30540 = BIT_FIELD_REF <*method, 8, 168>;
  D.30550 = D.30540 & 16;
  if (D.30550 != 0) goto <D.30544>; else goto <D.30545>;
  <D.30544>:
  opt = opt & 4294966783;
  <D.30545>:
  D.30551 = opt & 512;
  if (D.30551 != 0) goto <D.30552>; else goto <D.30553>;
  <D.30552>:
  target_domain = mono_get_root_domain ();
  goto <D.30554>;
  <D.30553>:
  target_domain = domain;
  <D.30554>:
  D.30525 = BIT_FIELD_REF <*method, 8, 160>;
  D.30526 = D.30525 & 124;
  if (D.30526 == 100) goto <D.30555>; else goto <D.30556>;
  <D.30555>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    D.30557 = info == 0B;
    D.30558 = (long int) D.30557;
    D.30559 = __builtin_expect (D.30558, 0);
    if (D.30559 != 0) goto <D.30560>; else goto <D.30561>;
    <D.30560>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6181, "info");
    <D.30561>:
    D.30562 = info->subtype;
    if (D.30562 == 17) goto <D.30563>; else goto <D.30564>;
    <D.30563>:
    {
      struct MonoGenericContext * ctx;

      ctx = 0B;
      D.30540 = BIT_FIELD_REF <*method, 8, 168>;
      D.30550 = D.30540 & 16;
      if (D.30550 != 0) goto <D.30565>; else goto <D.30566>;
      <D.30565>:
      ctx = mono_method_get_context (method);
      <D.30566>:
      method = info->d.synchronized_inner.method;
      if (ctx != 0B) goto <D.30567>; else goto <D.30568>;
      <D.30567>:
      method = mono_class_inflate_generic_method (method, ctx);
      <D.30568>:
    }
    <D.30564>:
  }
  <D.30556>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.30569>; else goto <D.30570>;
  <D.30569>:
  if (domain == target_domain) goto <D.30571>; else goto <D.30573>;
  <D.30573>:
  D.30574 = BIT_FIELD_REF <*info, 8, 168>;
  D.30575 = D.30574 & 128;
  if (D.30575 != 0) goto <D.30571>; else goto <D.30572>;
  <D.30571>:
  {
    struct MonoVTable * vtable;
    struct MonoException * tmpEx;

    D.30576 = mono_jit_stats.methods_lookups;
    D.30577 = D.30576 + 1;
    mono_jit_stats.methods_lookups = D.30577;
    D.30546 = method->klass;
    vtable = mono_class_vtable (domain, D.30546);
    D.30578 = vtable == 0B;
    D.30579 = (long int) D.30578;
    D.30580 = __builtin_expect (D.30579, 0);
    if (D.30580 != 0) goto <D.30581>; else goto <D.30582>;
    <D.30581>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6201, "vtable");
    <D.30582>:
    D.30583 = ex == 0B;
    D.30584 = (int) D.30583;
    tmpEx = mono_runtime_class_init_full (vtable, D.30584);
    if (tmpEx != 0B) goto <D.30585>; else goto <D.30586>;
    <D.30585>:
    *ex = tmpEx;
    D.30587 = 0B;
    return D.30587;
    <D.30586>:
    D.30588 = info->code_start;
    D.30587 = mono_create_ftnptr (target_domain, D.30588);
    return D.30587;
  }
  <D.30572>:
  <D.30570>:
  opt.171 = (int) opt;
  code = mono_jit_compile_method_inner (method, target_domain, opt.171, ex);
  if (code == 0B) goto <D.30590>; else goto <D.30591>;
  <D.30590>:
  D.30587 = 0B;
  return D.30587;
  <D.30591>:
  D.30525 = BIT_FIELD_REF <*method, 8, 160>;
  D.30592 = D.30525 & 124;
  D.30593 = D.30592 == 96;
  D.30594 = D.30592 == 112;
  D.30595 = D.30593 | D.30594;
  if (D.30595 != 0) goto <D.30596>; else goto <D.30597>;
  <D.30596>:
  {
    struct MonoDomain * d;

    try
      {
        D.30598 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.30598, code, &d);
        D.30599 = ji == 0B;
        D.30600 = (long int) D.30599;
        D.30601 = __builtin_expect (D.30600, 0);
        if (D.30601 != 0) goto <D.30602>; else goto <D.30603>;
        <D.30602>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6222, "ji");
        <D.30603>:
      }
    finally
      {
        d = {CLOBBER};
      }
  }
  <D.30597>:
  p = mono_create_ftnptr (target_domain, code);
  if (callinfo != 0B) goto <D.30604>; else goto <D.30605>;
  <D.30604>:
  mono_loader_lock ();
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30606>; else goto <D.30607>;
    <D.30606>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30607>:
    D.30608 = ret != 0;
    D.30609 = (long int) D.30608;
    D.30610 = __builtin_expect (D.30609, 0);
    if (D.30610 != 0) goto <D.30611>; else goto <D.30612>;
    <D.30611>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6230, "ret == 0");
    <D.30612>:
  }
  D.30613 = callinfo->wrapper;
  if (D.30613 == 0B) goto <D.30614>; else goto <D.30615>;
  <D.30614>:
  callinfo->wrapper = p;
  mono_register_jit_icall_wrapper (callinfo, p);
  <D.30615>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30616>; else goto <D.30617>;
    <D.30616>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30617>:
    D.30618 = ret != 0;
    D.30619 = (long int) D.30618;
    D.30620 = __builtin_expect (D.30619, 0);
    if (D.30620 != 0) goto <D.30621>; else goto <D.30622>;
    <D.30621>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6235, "ret == 0");
    <D.30622>:
  }
  mono_loader_unlock ();
  <D.30605>:
  D.30587 = p;
  return D.30587;
}


lookup_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.30624;
  _Bool D.30627;
  long int D.30628;
  long int D.30629;
  _Bool D.30634;
  long int D.30635;
  long int D.30636;
  struct MonoJitInfo * D.30639;
  struct MonoJitInfo * info;

  mono_loader_lock ();
  {
    int ret;

    D.30624 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.30624);
    if (ret != 0) goto <D.30625>; else goto <D.30626>;
    <D.30625>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30626>:
    D.30627 = ret != 0;
    D.30628 = (long int) D.30627;
    D.30629 = __builtin_expect (D.30628, 0);
    if (D.30629 != 0) goto <D.30630>; else goto <D.30631>;
    <D.30630>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5750, "ret == 0");
    <D.30631>:
  }
  info = lookup_method_inner (domain, method);
  {
    int ret;

    D.30624 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.30624);
    if (ret != 0) goto <D.30632>; else goto <D.30633>;
    <D.30632>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30633>:
    D.30634 = ret != 0;
    D.30635 = (long int) D.30634;
    D.30636 = __builtin_expect (D.30635, 0);
    if (D.30636 != 0) goto <D.30637>; else goto <D.30638>;
    <D.30637>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5752, "ret == 0");
    <D.30638>:
  }
  mono_loader_unlock ();
  D.30639 = info;
  return D.30639;
}


lookup_method_inner (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoInternalHashTable * D.30641;
  struct MonoJitInfo * D.30644;
  int D.30645;
  struct MonoJitInfo * ji;

  D.30641 = &domain->jit_code_hash;
  ji = mono_internal_hash_table_lookup (D.30641, method);
  if (ji != 0B) goto <D.30642>; else goto <D.30643>;
  <D.30642>:
  D.30644 = ji;
  return D.30644;
  <D.30643>:
  D.30645 = mono_method_is_generic_sharable (method, 0);
  if (D.30645 == 0) goto <D.30646>; else goto <D.30647>;
  <D.30646>:
  D.30644 = 0B;
  return D.30644;
  <D.30647>:
  D.30644 = mono_domain_lookup_shared_generic (domain, method);
  return D.30644;
}


mono_jit_compile_method_inner (struct MonoMethod * method, struct MonoDomain * target_domain, int opt, struct MonoException * * jit_ex)
{
  int D.30649;
  struct MonoMethod * method.172;
  struct MonoClass * D.30653;
  _Bool D.30656;
  long int D.30657;
  long int D.30658;
  void * D.30661;
  short unsigned int D.30664;
  int D.30665;
  int D.30666;
  short unsigned int D.30668;
  int D.30669;
  int D.30670;
  void * D.30671;
  void * D.30676;
  int D.30678;
  struct MonoImage * D.30681;
  char * D.30682;
  char * D.30683;
  int check_for_pending_exc.173;
  void * D.30686;
  struct MonoDomain * D.30689;
  int D.30692;
  struct MonoClass * D.30695;
  struct MonoClass * D.30696;
  char D.30700;
  int D.26150;
  int iftmp.174;
  int D.26149;
  const char[6] * D.30705;
  unsigned char D.30706;
  int D.30707;
  unsigned char D.30708;
  int D.30709;
  _Bool D.30710;
  _Bool D.30711;
  _Bool D.30712;
  const unsigned char * D.30715;
  unsigned char D.30716;
  int D.30717;
  const unsigned char * D.30718;
  unsigned char D.30719;
  int D.30720;
  _Bool D.30721;
  _Bool D.30722;
  const unsigned char * D.30725;
  unsigned char D.30726;
  int D.30727;
  const unsigned char * D.30728;
  unsigned char D.30729;
  int D.30730;
  _Bool D.30731;
  _Bool D.30732;
  const unsigned char * D.30735;
  unsigned char D.30736;
  int D.30737;
  const unsigned char * D.30738;
  unsigned char D.30739;
  int D.30740;
  _Bool D.30743;
  long int D.30744;
  long int D.30745;
  const void * D.30748;
  int D.26160;
  int iftmp.175;
  int D.26159;
  const char[7] * D.30754;
  unsigned char D.30755;
  int D.30756;
  unsigned char D.30757;
  int D.30758;
  _Bool D.30759;
  _Bool D.30760;
  _Bool D.30761;
  const unsigned char * D.30764;
  unsigned char D.30765;
  int D.30766;
  const unsigned char * D.30767;
  unsigned char D.30768;
  int D.30769;
  _Bool D.30770;
  _Bool D.30771;
  const unsigned char * D.30774;
  unsigned char D.30775;
  int D.30776;
  const unsigned char * D.30777;
  unsigned char D.30778;
  int D.30779;
  _Bool D.30780;
  _Bool D.30781;
  const unsigned char * D.30784;
  unsigned char D.30785;
  int D.30786;
  const unsigned char * D.30787;
  unsigned char D.30788;
  int D.30789;
  int D.26169;
  int iftmp.176;
  int D.26168;
  const char[12] * D.30797;
  unsigned char D.30798;
  int D.30799;
  unsigned char D.30800;
  int D.30801;
  _Bool D.30802;
  _Bool D.30803;
  _Bool D.30804;
  const unsigned char * D.30807;
  unsigned char D.30808;
  int D.30809;
  const unsigned char * D.30810;
  unsigned char D.30811;
  int D.30812;
  _Bool D.30813;
  _Bool D.30814;
  const unsigned char * D.30817;
  unsigned char D.30818;
  int D.30819;
  const unsigned char * D.30820;
  unsigned char D.30821;
  int D.30822;
  _Bool D.30823;
  _Bool D.30824;
  const unsigned char * D.30827;
  unsigned char D.30828;
  int D.30829;
  const unsigned char * D.30830;
  unsigned char D.30831;
  int D.30832;
  void * D.30835;
  int D.26178;
  int iftmp.177;
  int D.26177;
  const char[10] * D.30841;
  unsigned char D.30842;
  int D.30843;
  unsigned char D.30844;
  int D.30845;
  _Bool D.30846;
  _Bool D.30847;
  _Bool D.30848;
  const unsigned char * D.30851;
  unsigned char D.30852;
  int D.30853;
  const unsigned char * D.30854;
  unsigned char D.30855;
  int D.30856;
  _Bool D.30857;
  _Bool D.30858;
  const unsigned char * D.30861;
  unsigned char D.30862;
  int D.30863;
  const unsigned char * D.30864;
  unsigned char D.30865;
  int D.30866;
  _Bool D.30867;
  _Bool D.30868;
  const unsigned char * D.30871;
  unsigned char D.30872;
  int D.30873;
  const unsigned char * D.30874;
  unsigned char D.30875;
  int D.30876;
  void * D.30880;
  struct MonoImage * D.30881;
  struct MonoException * D.30882;
  unsigned char D.30883;
  unsigned char D.30884;
  <unnamed type> D.30887;
  unsigned int D.30888;
  _Bool D.30891;
  struct MonoTrampInfo * in_tinfo.178;
  struct MonoTrampInfo * out_tinfo.179;
  int mono_aot_only.180;
  const char * iftmp.181;
  struct MonoTrampInfo * tinfo.182;
  struct MonoDomain * D.30910;
  struct MonoException * D.30916;
  unsigned int opt.183;
  double D.30918;
  double D.30919;
  double D.30920;
  unsigned int D.30921;
  void * D.30925;
  char * D.30931;
  guint32 * D.30945;
  struct MonoMethod * D.30946;
  void * * D.30947;
  struct MonoDomain * D.30948;
  unsigned int D.30951;
  unsigned int D.30952;
  union mono_mutex_t * D.30955;
  _Bool D.30958;
  long int D.30959;
  long int D.30960;
  union mono_mutex_t * D.30963;
  _Bool D.30966;
  long int D.30967;
  long int D.30968;
  struct MonoDomain * D.30975;
  unsigned char D.30977;
  unsigned char D.30978;
  struct MonoJitInfo * D.30981;
  struct MonoMethod * D.30982;
  struct MonoInternalHashTable * D.30983;
  _Bool D.30986;
  long int D.30987;
  long int D.30988;
  struct MonoGenericSharingContext * D.30991;
  int D.30994;
  long unsigned int D.30997;
  long unsigned int D.30998;
  int D.30999;
  long unsigned int D.31002;
  long unsigned int D.31003;
  _Bool D.31007;
  long int D.31008;
  long int D.31009;
  int D.31012;
  int D.31013;
  int D.31014;
  int D.31015;
  int D.31016;
  int D.31017;
  int D.31018;
  int D.31019;
  int D.31020;
  int D.31021;
  int D.31022;
  int D.31023;
  int D.31024;
  int D.31025;
  int D.31026;
  int D.31027;
  int D.31028;
  int D.31029;
  int D.31030;
  int D.31031;
  int D.31032;
  int D.31033;
  int D.31034;
  int D.31035;
  int D.31036;
  int D.31037;
  int D.31038;
  int D.31039;
  int D.31040;
  void * D.31041;
  struct GHashTable * D.31042;
  void * D.31047;
  _Bool D.31050;
  long int D.31051;
  long int D.31052;
  _Bool D.31057;
  long int D.31058;
  long int D.31059;
  unsigned int D.31062;
  struct MonoMethod * D.31067;
  struct MonoMethod * D.31070;
  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.30649 = opt & 65536;
  if (D.30649 != 0) goto <D.30650>; else goto <D.30651>;
  <D.30650>:
  {
    struct MonoDomain * domain;

    domain = mono_domain_get ();
    method.172 = method;
    D.30653 = method.172->klass;
    mono_class_init (D.30653);
    method.172 = method;
    code = mono_aot_get_method (domain, method.172);
    if (code != 0B) goto <D.30654>; else goto <D.30655>;
    <D.30654>:
    method.172 = method;
    D.30653 = method.172->klass;
    vtable = mono_class_vtable (domain, D.30653);
    D.30656 = vtable == 0B;
    D.30657 = (long int) D.30656;
    D.30658 = __builtin_expect (D.30657, 0);
    if (D.30658 != 0) goto <D.30659>; else goto <D.30660>;
    <D.30659>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5817, "vtable");
    <D.30660>:
    mono_runtime_class_init (vtable);
    D.30661 = code;
    return D.30661;
    <D.30655>:
  }
  <D.30651>:
  method.172 = method;
  D.30664 = method.172->iflags;
  D.30665 = (int) D.30664;
  D.30666 = D.30665 & 4096;
  if (D.30666 != 0) goto <D.30662>; else goto <D.30667>;
  <D.30667>:
  method.172 = method;
  D.30668 = method.172->flags;
  D.30669 = (int) D.30668;
  D.30670 = D.30669 & 8192;
  if (D.30670 != 0) goto <D.30662>; else goto <D.30663>;
  <D.30662>:
  {
    struct MonoMethod * nm;
    struct MonoMethodPInvoke * piinfo;

    piinfo = method;
    D.30671 = piinfo->addr;
    if (D.30671 == 0B) goto <D.30672>; else goto <D.30673>;
    <D.30672>:
    method.172 = method;
    D.30664 = method.172->iflags;
    D.30665 = (int) D.30664;
    D.30666 = D.30665 & 4096;
    if (D.30666 != 0) goto <D.30674>; else goto <D.30675>;
    <D.30674>:
    method.172 = method;
    D.30676 = mono_lookup_internal_call (method.172);
    piinfo->addr = D.30676;
    goto <D.30677>;
    <D.30675>:
    method.172 = method;
    D.30664 = method.172->iflags;
    D.30665 = (int) D.30664;
    D.30678 = D.30665 & 1;
    if (D.30678 != 0) goto <D.30679>; else goto <D.30680>;
    <D.30679>:
    method.172 = method;
    D.30653 = method.172->klass;
    D.30681 = D.30653->image;
    D.30682 = D.30681->name;
    method.172 = method;
    D.30683 = mono_method_full_name (method.172, 1);
    monoeg_g_log (0B, 16, "Method \'%s\' in assembly \'%s\' contains native code that cannot be executed by Mono on this platform. The assembly was probably created using C++/CLI.\n", D.30683, D.30682);
    goto <D.30684>;
    <D.30680>:
    method.172 = method;
    mono_lookup_pinvoke_call (method.172, 0B, 0B);
    <D.30684>:
    <D.30677>:
    <D.30673>:
    check_for_pending_exc.173 = check_for_pending_exc;
    method.172 = method;
    nm = mono_marshal_get_native_wrapper (method.172, check_for_pending_exc.173, 0);
    D.30686 = mono_compile_method (nm);
    code = mono_get_addr_from_ftnptr (D.30686);
    jinfo = mono_jit_info_table_find (target_domain, code);
    if (jinfo == 0B) goto <D.30687>; else goto <D.30688>;
    <D.30687>:
    D.30689 = mono_domain_get ();
    jinfo = mono_jit_info_table_find (D.30689, code);
    <D.30688>:
    if (jinfo != 0B) goto <D.30690>; else goto <D.30691>;
    <D.30690>:
    method.172 = method;
    mono_profiler_method_end_jit (method.172, jinfo, 0);
    <D.30691>:
    D.30661 = code;
    return D.30661;
  }
  <D.30663>:
  method.172 = method;
  D.30664 = method.172->iflags;
  D.30665 = (int) D.30664;
  D.30692 = D.30665 & 3;
  if (D.30692 != 0) goto <D.30693>; else goto <D.30694>;
  <D.30693>:
  {
    const char * name;
    char * full_name;
    char * msg;
    struct MonoMethod * nm;

    method.172 = method;
    name = method.172->name;
    method.172 = method;
    D.30653 = method.172->klass;
    D.30695 = D.30653->parent;
    D.30696 = mono_defaults.multicastdelegate_class;
    if (D.30695 == D.30696) goto <D.30697>; else goto <D.30698>;
    <D.30697>:
    D.30700 = *name;
    if (D.30700 == 46) goto <D.30701>; else goto <D.30699>;
    <D.30701>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.30705 = ".ctor";
        D.30706 = MEM[(const unsigned char *)D.30705];
        D.30707 = (int) D.30706;
        D.30708 = *__s2;
        D.30709 = (int) D.30708;
        __result = D.30707 - D.30709;
        {
          D.30710 = __s2_len != 0;
          D.30711 = __result == 0;
          D.30712 = D.30710 & D.30711;
          if (D.30712 != 0) goto <D.30713>; else goto <D.30714>;
          <D.30713>:
          D.30715 = &MEM[(void *)".ctor" + 1B];
          D.30716 = *D.30715;
          D.30717 = (int) D.30716;
          D.30718 = __s2 + 1;
          D.30719 = *D.30718;
          D.30720 = (int) D.30719;
          __result = D.30717 - D.30720;
          D.30721 = __s2_len > 1;
          D.30711 = __result == 0;
          D.30722 = D.30721 & D.30711;
          if (D.30722 != 0) goto <D.30723>; else goto <D.30724>;
          <D.30723>:
          D.30725 = &MEM[(void *)".ctor" + 2B];
          D.30726 = *D.30725;
          D.30727 = (int) D.30726;
          D.30728 = __s2 + 2;
          D.30729 = *D.30728;
          D.30730 = (int) D.30729;
          __result = D.30727 - D.30730;
          D.30731 = __s2_len > 2;
          D.30711 = __result == 0;
          D.30732 = D.30731 & D.30711;
          if (D.30732 != 0) goto <D.30733>; else goto <D.30734>;
          <D.30733>:
          D.30735 = &MEM[(void *)".ctor" + 3B];
          D.30736 = *D.30735;
          D.30737 = (int) D.30736;
          D.30738 = __s2 + 3;
          D.30739 = *D.30738;
          D.30740 = (int) D.30739;
          __result = D.30737 - D.30740;
          <D.30734>:
          <D.30724>:
          <D.30714>:
        }
        D.26149 = __result;
      }
      iftmp.174 = -D.26149;
      goto <D.30741>;
      <D.30704>:
      iftmp.174 = __builtin_strcmp (name, ".ctor");
      <D.30741>:
      D.26150 = iftmp.174;
    }
    if (D.26150 == 0) goto <D.30742>; else goto <D.30699>;
    <D.30742>:
    {
      struct MonoJitICallInfo * mi;

      mi = mono_find_jit_icall_by_name ("mono_delegate_ctor");
      D.30743 = mi == 0B;
      D.30744 = (long int) D.30743;
      D.30745 = __builtin_expect (D.30744, 0);
      if (D.30745 != 0) goto <D.30746>; else goto <D.30747>;
      <D.30746>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5858, "mi");
      <D.30747>:
      D.30748 = mono_icall_get_wrapper_full (mi, 1);
      D.30661 = mono_get_addr_from_ftnptr (D.30748);
      return D.30661;
    }
    <D.30699>:
    D.30700 = *name;
    if (D.30700 == 73) goto <D.30750>; else goto <D.30749>;
    <D.30750>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.30754 = "Invoke";
        D.30755 = MEM[(const unsigned char *)D.30754];
        D.30756 = (int) D.30755;
        D.30757 = *__s2;
        D.30758 = (int) D.30757;
        __result = D.30756 - D.30758;
        {
          D.30759 = __s2_len != 0;
          D.30760 = __result == 0;
          D.30761 = D.30759 & D.30760;
          if (D.30761 != 0) goto <D.30762>; else goto <D.30763>;
          <D.30762>:
          D.30764 = &MEM[(void *)"Invoke" + 1B];
          D.30765 = *D.30764;
          D.30766 = (int) D.30765;
          D.30767 = __s2 + 1;
          D.30768 = *D.30767;
          D.30769 = (int) D.30768;
          __result = D.30766 - D.30769;
          D.30770 = __s2_len > 1;
          D.30760 = __result == 0;
          D.30771 = D.30770 & D.30760;
          if (D.30771 != 0) goto <D.30772>; else goto <D.30773>;
          <D.30772>:
          D.30774 = &MEM[(void *)"Invoke" + 2B];
          D.30775 = *D.30774;
          D.30776 = (int) D.30775;
          D.30777 = __s2 + 2;
          D.30778 = *D.30777;
          D.30779 = (int) D.30778;
          __result = D.30776 - D.30779;
          D.30780 = __s2_len > 2;
          D.30760 = __result == 0;
          D.30781 = D.30780 & D.30760;
          if (D.30781 != 0) goto <D.30782>; else goto <D.30783>;
          <D.30782>:
          D.30784 = &MEM[(void *)"Invoke" + 3B];
          D.30785 = *D.30784;
          D.30786 = (int) D.30785;
          D.30787 = __s2 + 3;
          D.30788 = *D.30787;
          D.30789 = (int) D.30788;
          __result = D.30786 - D.30789;
          <D.30783>:
          <D.30773>:
          <D.30763>:
        }
        D.26159 = __result;
      }
      iftmp.175 = -D.26159;
      goto <D.30790>;
      <D.30753>:
      iftmp.175 = __builtin_strcmp (name, "Invoke");
      <D.30790>:
      D.26160 = iftmp.175;
    }
    if (D.26160 == 0) goto <D.30791>; else goto <D.30749>;
    <D.30791>:
    method.172 = method;
    D.30653 = method.172->klass;
    D.30661 = mono_create_delegate_trampoline (target_domain, D.30653);
    return D.30661;
    <D.30749>:
    D.30700 = *name;
    if (D.30700 == 66) goto <D.30793>; else goto <D.30792>;
    <D.30793>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.30797 = "BeginInvoke";
        D.30798 = MEM[(const unsigned char *)D.30797];
        D.30799 = (int) D.30798;
        D.30800 = *__s2;
        D.30801 = (int) D.30800;
        __result = D.30799 - D.30801;
        {
          D.30802 = __s2_len != 0;
          D.30803 = __result == 0;
          D.30804 = D.30802 & D.30803;
          if (D.30804 != 0) goto <D.30805>; else goto <D.30806>;
          <D.30805>:
          D.30807 = &MEM[(void *)"BeginInvoke" + 1B];
          D.30808 = *D.30807;
          D.30809 = (int) D.30808;
          D.30810 = __s2 + 1;
          D.30811 = *D.30810;
          D.30812 = (int) D.30811;
          __result = D.30809 - D.30812;
          D.30813 = __s2_len > 1;
          D.30803 = __result == 0;
          D.30814 = D.30813 & D.30803;
          if (D.30814 != 0) goto <D.30815>; else goto <D.30816>;
          <D.30815>:
          D.30817 = &MEM[(void *)"BeginInvoke" + 2B];
          D.30818 = *D.30817;
          D.30819 = (int) D.30818;
          D.30820 = __s2 + 2;
          D.30821 = *D.30820;
          D.30822 = (int) D.30821;
          __result = D.30819 - D.30822;
          D.30823 = __s2_len > 2;
          D.30803 = __result == 0;
          D.30824 = D.30823 & D.30803;
          if (D.30824 != 0) goto <D.30825>; else goto <D.30826>;
          <D.30825>:
          D.30827 = &MEM[(void *)"BeginInvoke" + 3B];
          D.30828 = *D.30827;
          D.30829 = (int) D.30828;
          D.30830 = __s2 + 3;
          D.30831 = *D.30830;
          D.30832 = (int) D.30831;
          __result = D.30829 - D.30832;
          <D.30826>:
          <D.30816>:
          <D.30806>:
        }
        D.26168 = __result;
      }
      iftmp.176 = -D.26168;
      goto <D.30833>;
      <D.30796>:
      iftmp.176 = __builtin_strcmp (name, "BeginInvoke");
      <D.30833>:
      D.26169 = iftmp.176;
    }
    if (D.26169 == 0) goto <D.30834>; else goto <D.30792>;
    <D.30834>:
    method.172 = method;
    nm = mono_marshal_get_delegate_begin_invoke (method.172);
    D.30835 = mono_compile_method (nm);
    D.30661 = mono_get_addr_from_ftnptr (D.30835);
    return D.30661;
    <D.30792>:
    D.30700 = *name;
    if (D.30700 == 69) goto <D.30836>; else goto <D.30837>;
    <D.30836>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.30841 = "EndInvoke";
        D.30842 = MEM[(const unsigned char *)D.30841];
        D.30843 = (int) D.30842;
        D.30844 = *__s2;
        D.30845 = (int) D.30844;
        __result = D.30843 - D.30845;
        {
          D.30846 = __s2_len != 0;
          D.30847 = __result == 0;
          D.30848 = D.30846 & D.30847;
          if (D.30848 != 0) goto <D.30849>; else goto <D.30850>;
          <D.30849>:
          D.30851 = &MEM[(void *)"EndInvoke" + 1B];
          D.30852 = *D.30851;
          D.30853 = (int) D.30852;
          D.30854 = __s2 + 1;
          D.30855 = *D.30854;
          D.30856 = (int) D.30855;
          __result = D.30853 - D.30856;
          D.30857 = __s2_len > 1;
          D.30847 = __result == 0;
          D.30858 = D.30857 & D.30847;
          if (D.30858 != 0) goto <D.30859>; else goto <D.30860>;
          <D.30859>:
          D.30861 = &MEM[(void *)"EndInvoke" + 2B];
          D.30862 = *D.30861;
          D.30863 = (int) D.30862;
          D.30864 = __s2 + 2;
          D.30865 = *D.30864;
          D.30866 = (int) D.30865;
          __result = D.30863 - D.30866;
          D.30867 = __s2_len > 2;
          D.30847 = __result == 0;
          D.30868 = D.30867 & D.30847;
          if (D.30868 != 0) goto <D.30869>; else goto <D.30870>;
          <D.30869>:
          D.30871 = &MEM[(void *)"EndInvoke" + 3B];
          D.30872 = *D.30871;
          D.30873 = (int) D.30872;
          D.30874 = __s2 + 3;
          D.30875 = *D.30874;
          D.30876 = (int) D.30875;
          __result = D.30873 - D.30876;
          <D.30870>:
          <D.30860>:
          <D.30850>:
        }
        D.26177 = __result;
      }
      iftmp.177 = -D.26177;
      goto <D.30877>;
      <D.30840>:
      iftmp.177 = __builtin_strcmp (name, "EndInvoke");
      <D.30877>:
      D.26178 = iftmp.177;
    }
    if (D.26178 == 0) goto <D.30878>; else goto <D.30879>;
    <D.30878>:
    method.172 = method;
    nm = mono_marshal_get_delegate_end_invoke (method.172);
    D.30880 = mono_compile_method (nm);
    D.30661 = mono_get_addr_from_ftnptr (D.30880);
    return D.30661;
    <D.30879>:
    <D.30837>:
    <D.30698>:
    method.172 = method;
    full_name = mono_method_full_name (method.172, 1);
    msg = monoeg_g_strdup_printf ("Unrecognizable runtime implemented method \'%s\'", full_name);
    D.30881 = mono_defaults.corlib;
    D.30882 = mono_exception_from_name_msg (D.30881, "System", "InvalidProgramException", msg);
    *jit_ex = D.30882;
    monoeg_g_free (full_name);
    monoeg_g_free (msg);
    D.30661 = 0B;
    return D.30661;
  }
  <D.30694>:
  method.172 = method;
  D.30883 = BIT_FIELD_REF <*method.172, 8, 160>;
  D.30884 = D.30883 & 124;
  if (D.30884 == 100) goto <D.30885>; else goto <D.30886>;
  <D.30885>:
  {
    struct WrapperInfo * info;

    method.172 = method;
    info = mono_marshal_get_wrapper_info (method.172);
    D.30887 = info->subtype;
    D.30888 = D.30887 + 4294967278;
    if (D.30888 <= 1) goto <D.30889>; else goto <D.30890>;
    <D.30889>:
    {
      static struct MonoTrampInfo * in_tinfo;
      static struct MonoTrampInfo * out_tinfo;
      struct MonoTrampInfo * tinfo;
      struct MonoJitInfo * jinfo;
      gboolean is_in;

      try
        {
          D.30887 = info->subtype;
          D.30891 = D.30887 == 18;
          is_in = (gboolean) D.30891;
          if (is_in != 0) goto <D.30893>; else goto <D.30892>;
          <D.30893>:
          in_tinfo.178 = in_tinfo;
          if (in_tinfo.178 != 0B) goto <D.30895>; else goto <D.30892>;
          <D.30895>:
          in_tinfo.178 = in_tinfo;
          D.30661 = in_tinfo.178->code;
          return D.30661;
          <D.30892>:
          if (is_in == 0) goto <D.30896>; else goto <D.30897>;
          <D.30896>:
          out_tinfo.179 = out_tinfo;
          if (out_tinfo.179 != 0B) goto <D.30899>; else goto <D.30900>;
          <D.30899>:
          out_tinfo.179 = out_tinfo;
          D.30661 = out_tinfo.179->code;
          return D.30661;
          <D.30900>:
          <D.30897>:
          mono_aot_only.180 = mono_aot_only;
          if (mono_aot_only.180 != 0) goto <D.30902>; else goto <D.30903>;
          <D.30902>:
          if (is_in != 0) goto <D.30905>; else goto <D.30906>;
          <D.30905>:
          iftmp.181 = "gsharedvt_trampoline";
          goto <D.30907>;
          <D.30906>:
          iftmp.181 = "gsharedvt_out_trampoline";
          <D.30907>:
          mono_aot_get_trampoline_full (iftmp.181, &tinfo);
          goto <D.30908>;
          <D.30903>:
          mono_arch_get_gsharedvt_trampoline (&tinfo, 0);
          <D.30908>:
          tinfo.182 = tinfo;
          method.172 = method;
          jinfo = create_jit_info_for_trampoline (method.172, tinfo.182);
          D.30910 = mono_get_root_domain ();
          mono_jit_info_table_add (D.30910, jinfo);
          if (is_in != 0) goto <D.30911>; else goto <D.30912>;
          <D.30911>:
          tinfo.182 = tinfo;
          in_tinfo = tinfo.182;
          goto <D.30913>;
          <D.30912>:
          tinfo.182 = tinfo;
          out_tinfo = tinfo.182;
          <D.30913>:
          tinfo.182 = tinfo;
          D.30661 = tinfo.182->code;
          return D.30661;
        }
      finally
        {
          tinfo = {CLOBBER};
        }
    }
    <D.30890>:
  }
  <D.30886>:
  mono_aot_only.180 = mono_aot_only;
  if (mono_aot_only.180 != 0) goto <D.30914>; else goto <D.30915>;
  <D.30914>:
  {
    char * fullname;
    char * msg;

    method.172 = method;
    fullname = mono_method_full_name (method.172, 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.30916 = mono_get_exception_execution_engine (msg);
    *jit_ex = D.30916;
    monoeg_g_free (fullname);
    monoeg_g_free (msg);
    D.30661 = 0B;
    return D.30661;
  }
  <D.30915>:
  jit_timer = monoeg_g_timer_new ();
  opt.183 = (unsigned int) opt;
  method.172 = method;
  cfg = mini_method_compile (method.172, opt.183, target_domain, 1, 0);
  prof_method = cfg->method;
  monoeg_g_timer_stop (jit_timer);
  D.30918 = monoeg_g_timer_elapsed (jit_timer, 0B);
  D.30919 = mono_jit_stats.jit_time;
  D.30920 = D.30919 + D.30918;
  mono_jit_stats.jit_time = D.30920;
  monoeg_g_timer_destroy (jit_timer);
  D.30921 = cfg->exception_type;
  switch (D.30921) <default: <D.26206>, case 0: <D.26187>, case 1: <D.26199>, case 3: <D.26195>, case 4: <D.26196>, case 5: <D.26191>, case 6: <D.26190>, case 7: <D.26189>, case 8: <D.26192>, case 9: <D.26197>, case 10: <D.26198>, case 12: <D.26193>, case 13: <D.26203>, case 14: <D.26205>>
  <D.26187>:
  goto <D.26188>;
  <D.26189>:
  <D.26190>:
  <D.26191>:
  <D.26192>:
  <D.26193>:
  {
    struct MonoLoaderError * error;

    error = mono_loader_get_last_error ();
    if (error != 0B) goto <D.30922>; else goto <D.30923>;
    <D.30922>:
    ex = mono_loader_error_prepare_exception (error);
    goto <D.30924>;
    <D.30923>:
    D.30925 = cfg->exception_ptr;
    if (D.30925 != 0B) goto <D.30926>; else goto <D.30927>;
    <D.30926>:
    D.30925 = cfg->exception_ptr;
    ex = mono_class_get_exception_for_failure (D.30925);
    goto <D.30928>;
    <D.30927>:
    D.30921 = cfg->exception_type;
    if (D.30921 == 6) goto <D.30929>; else goto <D.30930>;
    <D.30929>:
    D.30931 = cfg->exception_message;
    D.30881 = mono_defaults.corlib;
    ex = mono_exception_from_name_msg (D.30881, "System", "MissingFieldException", D.30931);
    goto <D.30932>;
    <D.30930>:
    D.30921 = cfg->exception_type;
    if (D.30921 == 5) goto <D.30933>; else goto <D.30934>;
    <D.30933>:
    D.30931 = cfg->exception_message;
    D.30881 = mono_defaults.corlib;
    ex = mono_exception_from_name_msg (D.30881, "System", "MissingMethodException", D.30931);
    goto <D.30935>;
    <D.30934>:
    D.30921 = cfg->exception_type;
    if (D.30921 == 7) goto <D.30936>; else goto <D.30937>;
    <D.30936>:
    D.30931 = cfg->exception_message;
    D.30881 = mono_defaults.corlib;
    ex = mono_exception_from_name_msg (D.30881, "System", "TypeLoadException", D.30931);
    goto <D.30938>;
    <D.30937>:
    D.30921 = cfg->exception_type;
    if (D.30921 == 8) goto <D.30939>; else goto <D.30940>;
    <D.30939>:
    D.30931 = cfg->exception_message;
    D.30881 = mono_defaults.corlib;
    ex = mono_exception_from_name_msg (D.30881, "System", "FileNotFoundException", D.30931);
    goto <D.30941>;
    <D.30940>:
    D.30921 = cfg->exception_type;
    if (D.30921 == 12) goto <D.30942>; else goto <D.30943>;
    <D.30942>:
    D.30931 = cfg->exception_message;
    ex = mono_get_exception_bad_image_format (D.30931);
    goto <D.30944>;
    <D.30943>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 5975);
    <D.30944>:
    <D.30941>:
    <D.30938>:
    <D.30935>:
    <D.30932>:
    <D.30928>:
    <D.30924>:
    goto <D.26188>;
  }
  <D.26195>:
  D.30931 = cfg->exception_message;
  D.30881 = mono_defaults.corlib;
  ex = mono_exception_from_name_msg (D.30881, "System", "InvalidProgramException", D.30931);
  goto <D.26188>;
  <D.26196>:
  D.30931 = cfg->exception_message;
  D.30881 = mono_defaults.corlib;
  ex = mono_exception_from_name_msg (D.30881, "System.Security", "VerificationException", D.30931);
  goto <D.26188>;
  <D.26197>:
  D.30931 = cfg->exception_message;
  D.30881 = mono_defaults.corlib;
  ex = mono_exception_from_name_msg (D.30881, "System", "MethodAccessException", D.30931);
  goto <D.26188>;
  <D.26198>:
  D.30931 = cfg->exception_message;
  D.30881 = mono_defaults.corlib;
  ex = mono_exception_from_name_msg (D.30881, "System", "FieldAccessException", D.30931);
  goto <D.26188>;
  <D.26199>:
  {
    struct MonoSecurityManager * secman;
    struct MonoObject * exc;
    void * args[2];

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

    exp = cfg->exception_ptr;
    D.30947 = &cfg->exception_ptr;
    mono_gc_deregister_root (D.30947);
    ex = exp;
    goto <D.26188>;
  }
  <D.26205>:
  D.30948 = mono_domain_get ();
  ex = D.30948->out_of_memory_ex;
  goto <D.26188>;
  <D.26206>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 6018);
  <D.26188>:
  if (ex != 0B) goto <D.30949>; else goto <D.30950>;
  <D.30949>:
  D.30951 = cfg->prof_options;
  D.30952 = D.30951 & 16;
  if (D.30952 != 0) goto <D.30953>; else goto <D.30954>;
  <D.30953>:
  method.172 = method;
  mono_profiler_method_end_jit (method.172, 0B, 1);
  <D.30954>:
  mono_destroy_compile (cfg);
  *jit_ex = ex;
  D.30661 = 0B;
  return D.30661;
  <D.30950>:
  mono_loader_lock ();
  {
    int ret;

    D.30955 = &target_domain->lock.mutex;
    ret = pthread_mutex_lock (D.30955);
    if (ret != 0) goto <D.30956>; else goto <D.30957>;
    <D.30956>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30957>:
    D.30958 = ret != 0;
    D.30959 = (long int) D.30958;
    D.30960 = __builtin_expect (D.30959, 0);
    if (D.30960 != 0) goto <D.30961>; else goto <D.30962>;
    <D.30961>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6032, "ret == 0");
    <D.30962>:
  }
  {
    int ret;

    D.30963 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.30963);
    if (ret != 0) goto <D.30964>; else goto <D.30965>;
    <D.30964>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30965>:
    D.30966 = ret != 0;
    D.30967 = (long int) D.30966;
    D.30968 = __builtin_expect (D.30967, 0);
    if (D.30968 != 0) goto <D.30969>; else goto <D.30970>;
    <D.30969>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6037, "ret == 0");
    <D.30970>:
  }
  method.172 = method;
  info = lookup_method_inner (target_domain, method.172);
  if (info != 0B) goto <D.30971>; else goto <D.30972>;
  <D.30971>:
  D.30975 = mono_domain_get ();
  if (D.30975 == target_domain) goto <D.30973>; else goto <D.30976>;
  <D.30976>:
  D.30977 = BIT_FIELD_REF <*info, 8, 168>;
  D.30978 = D.30977 & 128;
  if (D.30978 != 0) goto <D.30973>; else goto <D.30974>;
  <D.30973>:
  code = info->code_start;
  <D.30974>:
  <D.30972>:
  if (code == 0B) goto <D.30979>; else goto <D.30980>;
  <D.30979>:
  D.30981 = cfg->jit_info;
  D.30981 = cfg->jit_info;
  D.30982 = D.30981->d.method;
  D.30983 = &target_domain->jit_code_hash;
  mono_internal_hash_table_insert (D.30983, D.30982, D.30981);
  {
    int ret;

    D.30963 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.30963);
    if (ret != 0) goto <D.30984>; else goto <D.30985>;
    <D.30984>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30985>:
    D.30986 = ret != 0;
    D.30987 = (long int) D.30986;
    D.30988 = __builtin_expect (D.30987, 0);
    if (D.30988 != 0) goto <D.30989>; else goto <D.30990>;
    <D.30989>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6050, "ret == 0");
    <D.30990>:
  }
  code = cfg->native_code;
  D.30991 = cfg->generic_sharing_context;
  if (D.30991 != 0B) goto <D.30992>; else goto <D.30993>;
  <D.30992>:
  method.172 = method;
  D.30994 = mono_method_is_generic_sharable (method.172, 0);
  if (D.30994 != 0) goto <D.30995>; else goto <D.30996>;
  <D.30995>:
  D.30997 = mono_stats.generics_shared_methods;
  D.30998 = D.30997 + 1;
  mono_stats.generics_shared_methods = D.30998;
  <D.30996>:
  <D.30993>:
  D.30999 = cfg->gsharedvt;
  if (D.30999 != 0) goto <D.31000>; else goto <D.31001>;
  <D.31000>:
  D.31002 = mono_stats.gsharedvt_methods;
  D.31003 = D.31002 + 1;
  mono_stats.gsharedvt_methods = D.31003;
  <D.31001>:
  goto <D.31004>;
  <D.30980>:
  {
    int ret;

    D.30963 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.30963);
    if (ret != 0) goto <D.31005>; else goto <D.31006>;
    <D.31005>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31006>:
    D.31007 = ret != 0;
    D.31008 = (long int) D.31007;
    D.31009 = __builtin_expect (D.31008, 0);
    if (D.31009 != 0) goto <D.31010>; else goto <D.31011>;
    <D.31010>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6058, "ret == 0");
    <D.31011>:
  }
  <D.31004>:
  jinfo = cfg->jit_info;
  prof_options = cfg->prof_options;
  D.31012 = mono_jit_stats.allocate_var;
  D.31013 = cfg->stat_allocate_var;
  D.31014 = D.31012 + D.31013;
  mono_jit_stats.allocate_var = D.31014;
  D.31015 = mono_jit_stats.locals_stack_size;
  D.31016 = cfg->stat_locals_stack_size;
  D.31017 = D.31015 + D.31016;
  mono_jit_stats.locals_stack_size = D.31017;
  D.31018 = mono_jit_stats.basic_blocks;
  D.31019 = cfg->stat_basic_blocks;
  D.31020 = D.31018 + D.31019;
  mono_jit_stats.basic_blocks = D.31020;
  D.31021 = mono_jit_stats.max_basic_blocks;
  D.31019 = cfg->stat_basic_blocks;
  D.31022 = MAX_EXPR <D.31021, D.31019>;
  mono_jit_stats.max_basic_blocks = D.31022;
  D.31023 = mono_jit_stats.cil_code_size;
  D.31024 = cfg->stat_cil_code_size;
  D.31025 = D.31023 + D.31024;
  mono_jit_stats.cil_code_size = D.31025;
  D.31026 = mono_jit_stats.regvars;
  D.31027 = cfg->stat_n_regvars;
  D.31028 = D.31026 + D.31027;
  mono_jit_stats.regvars = D.31028;
  D.31029 = mono_jit_stats.inlineable_methods;
  D.31030 = cfg->stat_inlineable_methods;
  D.31031 = D.31029 + D.31030;
  mono_jit_stats.inlineable_methods = D.31031;
  D.31032 = mono_jit_stats.inlined_methods;
  D.31033 = cfg->stat_inlined_methods;
  D.31034 = D.31032 + D.31033;
  mono_jit_stats.inlined_methods = D.31034;
  D.31035 = mono_jit_stats.cas_demand_generation;
  D.31036 = cfg->stat_cas_demand_generation;
  D.31037 = D.31035 + D.31036;
  mono_jit_stats.cas_demand_generation = D.31037;
  D.31038 = mono_jit_stats.code_reallocs;
  D.31039 = cfg->stat_code_reallocs;
  D.31040 = D.31038 + D.31039;
  mono_jit_stats.code_reallocs = D.31040;
  mono_destroy_compile (cfg);
  D.31041 = target_domain->runtime_info;
  D.31042 = MEM[(struct MonoJitDomainInfo *)D.31041].jump_target_hash;
  if (D.31042 != 0B) goto <D.31043>; else goto <D.31044>;
  <D.31043>:
  {
    struct MonoJumpInfo patch_info;
    struct MonoJumpList * jlist;
    struct GSList * tmp;

    try
      {
        method.172 = method;
        D.31041 = target_domain->runtime_info;
        D.31042 = MEM[(struct MonoJitDomainInfo *)D.31041].jump_target_hash;
        jlist = monoeg_g_hash_table_lookup (D.31042, method.172);
        if (jlist != 0B) goto <D.31045>; else goto <D.31046>;
        <D.31045>:
        patch_info.next = 0B;
        patch_info.ip.i = 0;
        patch_info.type = 4;
        method.172 = method;
        patch_info.data.method = method.172;
        method.172 = method;
        D.31041 = target_domain->runtime_info;
        D.31042 = MEM[(struct MonoJitDomainInfo *)D.31041].jump_target_hash;
        monoeg_g_hash_table_remove (D.31042, method.172);
        tmp = jlist->list;
        goto <D.26215>;
        <D.26214>:
        D.31047 = tmp->data;
        mono_arch_patch_code (0B, target_domain, D.31047, &patch_info, 0B, 1);
        tmp = tmp->next;
        <D.26215>:
        if (tmp != 0B) goto <D.26214>; else goto <D.26216>;
        <D.26216>:
        <D.31046>:
      }
    finally
      {
        patch_info = {CLOBBER};
      }
  }
  <D.31044>:
  mono_emit_jit_map (jinfo);
  {
    int ret;

    D.30955 = &target_domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30955);
    if (ret != 0) goto <D.31048>; else goto <D.31049>;
    <D.31048>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31049>:
    D.31050 = ret != 0;
    D.31051 = (long int) D.31050;
    D.31052 = __builtin_expect (D.31051, 0);
    if (D.31052 != 0) goto <D.31053>; else goto <D.31054>;
    <D.31053>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6109, "ret == 0");
    <D.31054>:
  }
  mono_loader_unlock ();
  method.172 = method;
  D.30653 = method.172->klass;
  vtable = mono_class_vtable (target_domain, D.30653);
  if (vtable == 0B) goto <D.31055>; else goto <D.31056>;
  <D.31055>:
  method.172 = method;
  D.30653 = method.172->klass;
  ex = mono_class_get_exception_for_failure (D.30653);
  D.31057 = ex == 0B;
  D.31058 = (long int) D.31057;
  D.31059 = __builtin_expect (D.31058, 0);
  if (D.31059 != 0) goto <D.31060>; else goto <D.31061>;
  <D.31060>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6115, "ex");
  <D.31061>:
  *jit_ex = ex;
  D.30661 = 0B;
  return D.30661;
  <D.31056>:
  D.31062 = prof_options & 16;
  if (D.31062 != 0) goto <D.31063>; else goto <D.31064>;
  <D.31063>:
  method.172 = method;
  D.30883 = BIT_FIELD_REF <*method.172, 8, 160>;
  D.30884 = D.30883 & 124;
  if (D.30884 == 24) goto <D.31065>; else goto <D.31066>;
  <D.31065>:
  method.172 = method;
  D.31067 = mono_marshal_method_from_wrapper (method.172);
  if (D.31067 != 0B) goto <D.31068>; else goto <D.31069>;
  <D.31068>:
  method.172 = method;
  D.31070 = mono_marshal_method_from_wrapper (method.172);
  mono_profiler_method_end_jit (D.31070, jinfo, 0);
  <D.31069>:
  <D.31066>:
  method.172 = method;
  mono_profiler_method_end_jit (method.172, jinfo, 0);
  method.172 = method;
  if (prof_method != method.172) goto <D.31071>; else goto <D.31072>;
  <D.31071>:
  mono_profiler_method_end_jit (prof_method, jinfo, 0);
  <D.31072>:
  <D.31064>:
  ex = mono_runtime_class_init_full (vtable, 0);
  if (ex != 0B) goto <D.31073>; else goto <D.31074>;
  <D.31073>:
  *jit_ex = ex;
  D.30661 = 0B;
  return D.30661;
  <D.31074>:
  D.30661 = code;
  return D.30661;
}


create_jit_info_for_trampoline (struct MonoMethod * wrapper, struct MonoTrampInfo * info)
{
  guint8 * D.31079;
  unsigned int info_len.184;
  struct GSList * D.31084;
  guint8 * D.31085;
  unsigned int D.31086;
  int D.31087;
  unsigned int info_len.185;
  unsigned int D.31089;
  struct MonoJitInfo * D.31090;
  struct MonoDomain * domain;
  struct MonoJitInfo * jinfo;
  guint8 * uw_info;
  guint32 info_len;

  try
    {
      domain = mono_get_root_domain ();
      D.31079 = info->uw_info;
      if (D.31079 != 0B) goto <D.31080>; else goto <D.31081>;
      <D.31080>:
      uw_info = info->uw_info;
      info_len.184 = info->uw_info_len;
      info_len = info_len.184;
      goto <D.31083>;
      <D.31081>:
      D.31084 = info->unwind_ops;
      uw_info = mono_unwind_ops_encode (D.31084, &info_len);
      <D.31083>:
      jinfo = mono_domain_alloc0 (domain, 28);
      jinfo->d.method = wrapper;
      D.31085 = info->code;
      jinfo->code_start = D.31085;
      D.31086 = info->code_size;
      D.31087 = (int) D.31086;
      jinfo->code_size = D.31087;
      info_len.185 = info_len;
      D.31089 = mono_cache_unwind_info (uw_info, info_len.185);
      jinfo->used_regs = D.31089;
      D.31090 = jinfo;
      return D.31090;
    }
  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.186;
  unsigned int D.31094;
  unsigned char D.31103;
  unsigned char D.31104;
  int D.31105;
  int D.31106;
  void * D.31109;
  struct MonoDomain * target_domain;
  struct MonoJitInfo * info;

  default_opt.186 = default_opt;
  D.31094 = default_opt.186 & 512;
  if (D.31094 != 0) goto <D.31095>; else goto <D.31096>;
  <D.31095>:
  target_domain = mono_get_root_domain ();
  goto <D.31097>;
  <D.31096>:
  target_domain = domain;
  <D.31097>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.31098>; else goto <D.31099>;
  <D.31098>:
  if (domain == target_domain) goto <D.31100>; else goto <D.31102>;
  <D.31102>:
  D.31103 = BIT_FIELD_REF <*info, 8, 168>;
  D.31104 = D.31103 & 128;
  if (D.31104 != 0) goto <D.31100>; else goto <D.31101>;
  <D.31100>:
  D.31105 = mono_jit_stats.methods_lookups;
  D.31106 = D.31105 + 1;
  mono_jit_stats.methods_lookups = D.31106;
  if (ji != 0B) goto <D.31107>; else goto <D.31108>;
  <D.31107>:
  *ji = info;
  <D.31108>:
  D.31109 = info->code_start;
  return D.31109;
  <D.31101>:
  <D.31099>:
  if (ji != 0B) goto <D.31110>; else goto <D.31111>;
  <D.31110>:
  *ji = 0B;
  <D.31111>:
  D.31109 = 0B;
  return D.31109;
}


mono_get_optimizations_for_method (struct MonoMethod * method, guint32 default_opt)
{
  _Bool D.31113;
  long int D.31114;
  long int D.31115;
  int mono_do_single_method_regression.187;
  guint32 D.31121;
  struct MonoMethod * mono_current_single_method.188;
  struct GHashTable * mono_single_method_hash.189;
  struct GHashTable * mono_single_method_hash.190;
  void * D.31129;
  struct GSList * mono_single_method_list.191;
  struct GSList * mono_single_method_list.192;

  D.31113 = method == 0B;
  D.31114 = (long int) D.31113;
  D.31115 = __builtin_expect (D.31114, 0);
  if (D.31115 != 0) goto <D.31116>; else goto <D.31117>;
  <D.31116>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6380, "method");
  <D.31117>:
  mono_do_single_method_regression.187 = mono_do_single_method_regression;
  if (mono_do_single_method_regression.187 == 0) goto <D.31119>; else goto <D.31120>;
  <D.31119>:
  D.31121 = default_opt;
  return D.31121;
  <D.31120>:
  mono_current_single_method.188 = mono_current_single_method;
  if (mono_current_single_method.188 == 0B) goto <D.31123>; else goto <D.31124>;
  <D.31123>:
  mono_single_method_hash.189 = mono_single_method_hash;
  if (mono_single_method_hash.189 == 0B) goto <D.31126>; else goto <D.31127>;
  <D.31126>:
  mono_single_method_hash.190 = monoeg_g_hash_table_new (monoeg_g_direct_hash, monoeg_g_direct_equal);
  mono_single_method_hash = mono_single_method_hash.190;
  <D.31127>:
  mono_single_method_hash.189 = mono_single_method_hash;
  D.31129 = monoeg_g_hash_table_lookup (mono_single_method_hash.189, method);
  if (D.31129 == 0B) goto <D.31130>; else goto <D.31131>;
  <D.31130>:
  mono_single_method_hash.189 = mono_single_method_hash;
  monoeg_g_hash_table_insert_replace (mono_single_method_hash.189, method, method, 0);
  mono_single_method_list.191 = mono_single_method_list;
  mono_single_method_list.192 = monoeg_g_slist_prepend (mono_single_method_list.191, method);
  mono_single_method_list = mono_single_method_list.192;
  <D.31131>:
  D.31121 = default_opt;
  return D.31121;
  <D.31124>:
  mono_current_single_method.188 = mono_current_single_method;
  if (method == mono_current_single_method.188) goto <D.31134>; else goto <D.31135>;
  <D.31134>:
  D.31121 = mono_single_method_regression_opt;
  return D.31121;
  <D.31135>:
  D.31121 = default_opt;
  return D.31121;
}


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

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


mono_sigfpe_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  void * D.31139;
  struct MonoDomain * D.31140;
  int D.31141;
  int D.31147;
  struct MonoException * exc;
  struct MonoJitInfo * ji;
  void * ctx;

  exc = 0B;
  ctx = context;
  D.31139 = mono_arch_ip_from_context (ctx);
  D.31140 = mono_domain_get ();
  ji = mono_jit_info_table_find (D.31140, D.31139);
  D.31141 = mono_arch_is_int_overflow (ctx, info);
  if (D.31141 != 0) goto <D.31142>; else goto <D.31143>;
  <D.31142>:
  exc = mono_get_exception_overflow ();
  goto <D.31144>;
  <D.31143>:
  exc = mono_get_exception_divide_by_zero ();
  <D.31144>:
  if (ji == 0B) goto <D.31145>; else goto <D.31146>;
  <D.31145>:
  D.31147 = mono_chain_signal (_dummy, info, context);
  if (D.31147 != 0) goto <D.31148>; else goto <D.31149>;
  <D.31148>:
  return;
  <D.31149>:
  mono_handle_native_sigsegv (11, ctx);
  <D.31146>:
  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.193;
  int D.31152;
  int D.31155;
  void * D.31158;
  int D.31159;
  struct MonoDomain * D.31164;
  int D.31166;
  void * D.31169;
  struct MonoDomain * D.31170;
  int D.31173;
  struct MonoJitInfo * ji;
  struct MonoJitTlsData * jit_tls;
  void * fault_addr;
  void * ctx;

  mono_jit_tls_id.193 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.193);
  fault_addr = 0B;
  ctx = context;
  D.31152 = mono_arch_is_single_step_event (info, ctx);
  if (D.31152 != 0) goto <D.31153>; else goto <D.31154>;
  <D.31153>:
  mono_debugger_agent_single_step_event (ctx);
  return;
  <D.31154>:
  D.31155 = mono_arch_is_breakpoint_event (info, ctx);
  if (D.31155 != 0) goto <D.31156>; else goto <D.31157>;
  <D.31156>:
  mono_debugger_agent_breakpoint_hit (ctx);
  return;
  <D.31157>:
  fault_addr = info->_sifields._sigfault.si_addr;
  D.31158 = info->_sifields._sigfault.si_addr;
  D.31159 = mono_aot_is_pagefault (D.31158);
  if (D.31159 != 0) goto <D.31160>; else goto <D.31161>;
  <D.31160>:
  D.31158 = info->_sifields._sigfault.si_addr;
  mono_aot_handle_pagefault (D.31158);
  return;
  <D.31161>:
  D.31164 = mono_domain_get ();
  if (D.31164 == 0B) goto <D.31162>; else goto <D.31165>;
  <D.31165>:
  if (jit_tls == 0B) goto <D.31162>; else goto <D.31163>;
  <D.31162>:
  D.31166 = mono_chain_signal (_dummy, info, context);
  if (D.31166 != 0) goto <D.31167>; else goto <D.31168>;
  <D.31167>:
  return;
  <D.31168>:
  mono_handle_native_sigsegv (11, ctx);
  <D.31163>:
  D.31169 = mono_arch_ip_from_context (ctx);
  D.31170 = mono_domain_get ();
  ji = mono_jit_info_table_find (D.31170, D.31169);
  if (ji == 0B) goto <D.31171>; else goto <D.31172>;
  <D.31171>:
  D.31173 = mono_chain_signal (_dummy, info, context);
  if (D.31173 != 0) goto <D.31174>; else goto <D.31175>;
  <D.31174>:
  return;
  <D.31175>:
  mono_handle_native_sigsegv (11, ctx);
  <D.31172>:
  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.31177;
  long int D.31178;
  long int D.31179;
  void * * vtable_trampolines.194;
  int D.31186;
  int vtable_trampolines_size.195;
  _Bool D.31190;
  long int D.31191;
  long int D.31192;
  int iftmp.196;
  unsigned int new_size.197;
  unsigned int D.31203;
  unsigned int vtable_trampolines_size.198;
  unsigned int D.31207;
  _Bool D.31210;
  long int D.31211;
  long int D.31212;
  unsigned int index.199;
  unsigned int D.31216;
  void * * D.31217;
  void * D.31218;
  struct MonoDomain * D.31221;
  void * slot_index.200;
  void * D.31223;
  void * D.31224;
  int index;

  index = slot_index + 19;
  D.31177 = slot_index < -19;
  D.31178 = (long int) D.31177;
  D.31179 = __builtin_expect (D.31178, 0);
  if (D.31179 != 0) goto <D.31180>; else goto <D.31181>;
  <D.31180>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6834, "slot_index >= - MONO_IMT_SIZE");
  <D.31181>:
  vtable_trampolines.194 = vtable_trampolines;
  if (vtable_trampolines.194 == 0B) goto <D.31182>; else goto <D.31185>;
  <D.31185>:
  D.31186 = slot_index + 19;
  vtable_trampolines_size.195 = vtable_trampolines_size;
  if (D.31186 >= vtable_trampolines_size.195) goto <D.31182>; else goto <D.31183>;
  <D.31182>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.31188>; else goto <D.31189>;
    <D.31188>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31189>:
    D.31190 = ret != 0;
    D.31191 = (long int) D.31190;
    D.31192 = __builtin_expect (D.31191, 0);
    if (D.31192 != 0) goto <D.31193>; else goto <D.31194>;
    <D.31193>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6836, "ret == 0");
    <D.31194>:
  }
  vtable_trampolines.194 = vtable_trampolines;
  if (vtable_trampolines.194 == 0B) goto <D.31195>; else goto <D.31197>;
  <D.31197>:
  vtable_trampolines_size.195 = vtable_trampolines_size;
  if (index >= vtable_trampolines_size.195) goto <D.31195>; else goto <D.31196>;
  <D.31195>:
  {
    int new_size;
    void * new_table;

    vtable_trampolines_size.195 = vtable_trampolines_size;
    if (vtable_trampolines_size.195 != 0) goto <D.31199>; else goto <D.31200>;
    <D.31199>:
    vtable_trampolines_size.195 = vtable_trampolines_size;
    iftmp.196 = vtable_trampolines_size.195 * 2;
    goto <D.31201>;
    <D.31200>:
    iftmp.196 = 128;
    <D.31201>:
    new_size = iftmp.196;
    goto <D.26372>;
    <D.26371>:
    new_size = new_size * 2;
    <D.26372>:
    if (new_size <= index) goto <D.26371>; else goto <D.26373>;
    <D.26373>:
    new_size.197 = (unsigned int) new_size;
    D.31203 = new_size.197 * 4;
    new_table = monoeg_malloc0 (D.31203);
    vtable_trampolines.194 = vtable_trampolines;
    if (vtable_trampolines.194 != 0B) goto <D.31204>; else goto <D.31205>;
    <D.31204>:
    vtable_trampolines_size.195 = vtable_trampolines_size;
    vtable_trampolines_size.198 = (unsigned int) vtable_trampolines_size.195;
    D.31207 = vtable_trampolines_size.198 * 4;
    vtable_trampolines.194 = vtable_trampolines;
    memcpy (new_table, vtable_trampolines.194, D.31207);
    <D.31205>:
    vtable_trampolines.194 = vtable_trampolines;
    monoeg_g_free (vtable_trampolines.194);
    mono_memory_barrier ();
    vtable_trampolines = new_table;
    vtable_trampolines_size = new_size;
  }
  <D.31196>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.31208>; else goto <D.31209>;
    <D.31208>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31209>:
    D.31210 = ret != 0;
    D.31211 = (long int) D.31210;
    D.31212 = __builtin_expect (D.31211, 0);
    if (D.31212 != 0) goto <D.31213>; else goto <D.31214>;
    <D.31213>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6853, "ret == 0");
    <D.31214>:
  }
  <D.31183>:
  vtable_trampolines.194 = vtable_trampolines;
  index.199 = (unsigned int) index;
  D.31216 = index.199 * 4;
  D.31217 = vtable_trampolines.194 + D.31216;
  D.31218 = *D.31217;
  if (D.31218 == 0B) goto <D.31219>; else goto <D.31220>;
  <D.31219>:
  vtable_trampolines.194 = vtable_trampolines;
  index.199 = (unsigned int) index;
  D.31216 = index.199 * 4;
  D.31217 = vtable_trampolines.194 + D.31216;
  D.31221 = mono_get_root_domain ();
  slot_index.200 = (void *) slot_index;
  D.31223 = mono_create_specific_trampoline (slot_index.200, 12, D.31221, 0B);
  *D.31217 = D.31223;
  <D.31220>:
  vtable_trampolines.194 = vtable_trampolines;
  index.199 = (unsigned int) index;
  D.31216 = index.199 * 4;
  D.31217 = vtable_trampolines.194 + D.31216;
  D.31224 = *D.31217;
  return D.31224;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mini_get_debug_options ()
{
  struct MonoDebugOptions * D.31226;

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


mini_init (const char * filename, const char * runtime_version)
{
  int D.31228;
  int default_opt_set.201;
  int D.31234;
  unsigned int default_opt.202;
  int mono_aot_only.203;
  int D.31239;
  struct MonoCodeManager * global_codeman.204;
  struct MonoCodeManager * global_codeman.205;
  struct GHashTable * jit_icall_name_hash.206;
  int mono_use_imt.207;
  const gchar * D.31248;
  const gchar * D.31251;
  struct MonoDebugOptions * D.31255;
  int D.31256;
  unsigned int default_opt.208;
  unsigned int D.31264;
  int D.31267;
  struct MonoCodeManager * D.31275;
  void * D.31281;
  void * D.31282;
  void * D.31283;
  int mono_compile_aot.209;
  struct MonoDomain * D.31287;
  struct MonoDomain * domain;
  struct MonoRuntimeCallbacks callbacks;
  struct MonoThreadInfoRuntimeCallbacks ticallbacks;

  try
    {
      D.31228 = access ("/proc/self/maps", 0);
      if (D.31228 != 0) goto <D.31229>; else goto <D.31230>;
      <D.31229>:
      monoeg_g_print ("Mono requires /proc to be mounted.\n");
      exit (1);
      <D.31230>:
      InitializeCriticalSection (&jit_mutex);
      default_opt_set.201 = default_opt_set;
      if (default_opt_set.201 == 0) goto <D.31232>; else goto <D.31233>;
      <D.31232>:
      D.31234 = mono_parse_default_optimizations (0B);
      default_opt.202 = (unsigned int) D.31234;
      default_opt = default_opt.202;
      <D.31233>:
      mono_aot_only.203 = mono_aot_only;
      if (mono_aot_only.203 != 0) goto <D.31237>; else goto <D.31238>;
      <D.31237>:
      mono_set_generic_sharing_vt_supported (1);
      <D.31238>:
      D.31239 = mono_x86_have_tls_get ();
      mono_runtime_set_has_tls_get (D.31239);
      global_codeman.204 = global_codeman;
      if (global_codeman.204 == 0B) goto <D.31241>; else goto <D.31242>;
      <D.31241>:
      global_codeman.205 = mono_code_manager_new ();
      global_codeman = global_codeman.205;
      <D.31242>:
      jit_icall_name_hash.206 = 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.206;
      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.207 = mono_use_imt;
      if (mono_use_imt.207 != 0) goto <D.31246>; else goto <D.31247>;
      <D.31246>:
      callbacks.get_vtable_trampoline = mini_get_vtable_trampoline;
      callbacks.get_imt_trampoline = mini_get_imt_trampoline;
      <D.31247>:
      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.31248 = monoeg_g_getenv ("MONO_DEBUG");
      if (D.31248 != 0B) goto <D.31249>; else goto <D.31250>;
      <D.31249>:
      mini_parse_debug_options ();
      <D.31250>:
      mono_code_manager_init ();
      mono_hwcap_init ();
      mono_arch_cpu_init ();
      mono_arch_init ();
      mono_unwind_init ();
      D.31251 = monoeg_g_getenv ("MONO_XDEBUG");
      if (D.31251 != 0B) goto <D.31252>; else goto <D.31253>;
      <D.31252>:
      {
        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.31254>;
      <D.31253>:
      D.31255 = mini_get_debug_options ();
      D.31256 = D.31255->gdb;
      if (D.31256 != 0) goto <D.31257>; else goto <D.31258>;
      <D.31257>:
      mono_xdebug_init ("gdb");
      mono_dont_free_domains = 1;
      mono_using_xdebug = 1;
      <D.31258>:
      <D.31254>:
      mono_trampolines_init ();
      if (0 != 0) goto <D.31259>; else goto <D.31260>;
      <D.31259>:
      if (0 != 0) goto <D.31261>; else goto <D.31262>;
      <D.31261>:
      monoeg_g_log (0B, 4, "No vtable supported in g_thread_init");
      <D.26596>:
      goto <D.26596>;
      <D.31262>:
      <D.31260>:
      mono_native_tls_alloc (&mono_jit_tls_id, 0B);
      default_opt.208 = default_opt;
      D.31264 = default_opt.208 & 65536;
      if (D.31264 != 0) goto <D.31265>; else goto <D.31266>;
      <D.31265>:
      mono_aot_init ();
      <D.31266>:
      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.31267 = debug_options.collect_pagefault_stats;
      if (D.31267 != 0) goto <D.31268>; else goto <D.31269>;
      <D.31268>:
      mono_aot_set_make_unreadable (1);
      <D.31269>:
      if (runtime_version != 0B) goto <D.31270>; else goto <D.31271>;
      <D.31270>:
      domain = mono_init_version (filename, runtime_version);
      goto <D.31272>;
      <D.31271>:
      domain = mono_init_from_assembly (filename, filename);
      <D.31272>:
      mono_aot_only.203 = mono_aot_only;
      if (mono_aot_only.203 != 0) goto <D.31273>; else goto <D.31274>;
      <D.31273>:
      D.31275 = domain->code_mp;
      mono_code_manager_set_read_only (D.31275);
      mono_marshal_use_aot_wrappers (1);
      <D.31274>:
      mono_use_imt.207 = mono_use_imt;
      if (mono_use_imt.207 != 0) goto <D.31276>; else goto <D.31277>;
      <D.31276>:
      mono_aot_only.203 = mono_aot_only;
      if (mono_aot_only.203 != 0) goto <D.31278>; else goto <D.31279>;
      <D.31278>:
      mono_install_imt_thunk_builder (mono_aot_get_imt_thunk);
      goto <D.31280>;
      <D.31279>:
      mono_install_imt_thunk_builder (mono_arch_build_imt_thunk);
      <D.31280>:
      <D.31277>:
      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.31281 = mono_get_throw_exception ();
      register_dyn_icall (D.31281, "mono_arch_throw_exception", "void object", 1);
      D.31282 = mono_get_rethrow_exception ();
      register_dyn_icall (D.31282, "mono_arch_rethrow_exception", "void object", 1);
      D.31283 = mono_get_throw_corlib_exception ();
      register_dyn_icall (D.31283, "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 (485, "__emul_lmul", "long long long", mono_llmult, "mono_llmult", 1);
      register_opcode_emulation (486, "__emul_ldiv", "long long long", mono_lldiv, "mono_lldiv", 0);
      register_opcode_emulation (487, "__emul_ldiv_un", "long long long", mono_lldiv_un, "mono_lldiv_un", 0);
      register_opcode_emulation (488, "__emul_lrem", "long long long", mono_llrem, "mono_llrem", 0);
      register_opcode_emulation (489, "__emul_lrem_un", "long long long", mono_llrem_un, "mono_llrem_un", 0);
      register_opcode_emulation (514, "__emul_lmul_ovf_un", "long long long", mono_llmult_ovf_un, "mono_llmult_ovf_un", 0);
      register_opcode_emulation (513, "__emul_lmul_ovf", "long long long", mono_llmult_ovf, "mono_llmult_ovf", 0);
      register_opcode_emulation (688, "__emul_fconv_to_u8", "ulong double", mono_fconv_u8, "mono_fconv_u8", 0);
      register_opcode_emulation (687, "__emul_fconv_to_u4", "uint32 double", mono_fconv_u4, "mono_fconv_u4", 0);
      register_opcode_emulation (716, "__emul_fconv_to_ovf_i8", "long double", mono_fconv_ovf_i8, "mono_fconv_ovf_i8", 0);
      register_opcode_emulation (717, "__emul_fconv_to_ovf_u8", "ulong double", mono_fconv_ovf_u8, "mono_fconv_ovf_u8", 0);
      register_opcode_emulation (731, "__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_simd_intrinsics_init ();
      mono_tasklets_init ();
      mono_compile_aot.209 = mono_compile_aot;
      if (mono_compile_aot.209 != 0) goto <D.31285>; else goto <D.31286>;
      <D.31285>:
      mono_runtime_set_no_exec (1);
      <D.31286>:
      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.31287 = domain;
      return D.31287;
    }
  finally
    {
      callbacks = {CLOBBER};
      ticallbacks = {CLOBBER};
    }
}


mono_thread_attach_cb (intptr_t tid, void * stack_start)
{
  <unnamed type> D.31292;
  unsigned int D.31293;
  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.31290>; else goto <D.31291>;
  <D.31290>:
  thread->jit_data = jit_tls;
  <D.31291>:
  D.31292 = mono_profiler_get_events ();
  D.31293 = D.31292 & 32768;
  if (D.31293 != 0) goto <D.31294>; else goto <D.31295>;
  <D.31294>:
  mono_runtime_setup_stat_profiler ();
  <D.31295>:
  mono_arch_cpu_init ();
}


mono_thread_abort_dummy (struct MonoObject * obj)
{
  void (*<T360b>) (struct MonoObject *) mono_thread_attach_aborted_cb.210;

  mono_thread_attach_aborted_cb.210 = mono_thread_attach_aborted_cb;
  if (mono_thread_attach_aborted_cb.210 != 0B) goto <D.31297>; else goto <D.31298>;
  <D.31297>:
  mono_thread_attach_aborted_cb.210 = mono_thread_attach_aborted_cb;
  mono_thread_attach_aborted_cb.210 (obj);
  goto <D.31299>;
  <D.31298>:
  mono_thread_abort (obj);
  <D.31299>:
}


mono_thread_abort (struct MonoObject * obj)
{
  <unnamed type> D.31303;
  struct MonoVTable * D.31305;
  struct MonoClass * D.31306;
  struct MonoClass * D.31307;

  D.31303 = mono_runtime_unhandled_exception_policy_get ();
  if (D.31303 == 0) goto <D.31300>; else goto <D.31304>;
  <D.31304>:
  D.31305 = obj->vtable;
  D.31306 = D.31305->klass;
  D.31307 = mono_defaults.threadabortexception_class;
  if (D.31306 == D.31307) goto <D.31300>; else goto <D.31301>;
  <D.31300>:
  mono_thread_exit ();
  goto <D.31302>;
  <D.31301>:
  mono_invoke_unhandled_exception_hook (obj);
  <D.31302>:
}


setup_jit_tls_data (void * stack_start, void * abort_func)
{
  unsigned int mono_jit_tls_id.211;
  void * D.31311;
  void (*<T360b>) (struct MonoObject *) abort_func.212;
  struct MonoJitTlsData * jit_tls;
  struct MonoLMF * lmf;

  mono_jit_tls_id.211 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.211);
  if (jit_tls != 0B) goto <D.31309>; else goto <D.31310>;
  <D.31309>:
  D.31311 = jit_tls;
  return D.31311;
  <D.31310>:
  jit_tls = monoeg_malloc0 (268);
  abort_func.212 = (void (*<T360b>) (struct MonoObject *)) abort_func;
  jit_tls->abort_func = abort_func.212;
  jit_tls->end_of_stack = stack_start;
  mono_set_jit_tls (jit_tls);
  lmf = monoeg_malloc0 (36);
  lmf->ebp = 4294967295;
  jit_tls->first_lmf = lmf;
  mono_lmf = lmf;
  mono_set_lmf_addr (&mono_lmf);
  mono_setup_altstack (jit_tls);
  D.31311 = jit_tls;
  return D.31311;
}


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

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


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.31315;
  int D.31316;
  _Bool D.31317;

  D.31316 = pthread_setspecific (key, value);
  D.31317 = D.31316 == 0;
  D.31315 = (int) D.31317;
  return D.31315;
}


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


mono_jit_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  short unsigned int D.31323;
  int D.31324;
  int D.31325;
  unsigned char D.31328;
  unsigned char D.31329;
  struct MonoObject * D.31332;
  union mono_mutex_t * D.31333;
  _Bool D.31336;
  long int D.31337;
  long int D.31338;
  struct GHashTable * D.31341;
  _Bool D.31344;
  long int D.31345;
  long int D.31346;
  <unnamed type> D.31351;
  struct MonoClass * D.31354;
  unsigned char D.31355;
  struct MonoException * D.31360;
  struct MonoException * D.31362;
  struct MonoVTable * D.31363;
  struct MonoVTable * D.31364;
  _Bool D.31365;
  long int D.31366;
  long int D.31367;
  unsigned char D.31370;
  short unsigned int D.31373;
  unsigned int D.31374;
  unsigned int D.31375;
  int mono_aot_only.214;
  unsigned int default_opt.215;
  unsigned int D.31385;
  void * D.31386;
  void * D.31387;
  struct MonoException * jit_ex.216;
  _Bool D.31391;
  long int D.31392;
  long int D.31393;
  int D.31398;
  void * D.31399;
  struct MonoDynCallInfo * D.31401;
  void * D.31404;
  _Bool D.31407;
  long int D.31408;
  long int D.31409;
  _Bool D.31417;
  long int D.31418;
  long int D.31419;
  void * D.31422;
  struct MonoException * D.31425;
  struct MonoObject * D.31426;
  struct MonoMethod * invoke;
  struct MonoMethod * callee;
  struct MonoObject * (*<T3278>) (struct MonoObject *, void * *, struct MonoObject * *, void *) runtime_invoke;
  struct MonoDomain * domain;
  struct MonoJitDomainInfo * domain_info;
  struct RuntimeInvokeInfo * info;
  struct RuntimeInvokeInfo * info2;

  domain = mono_domain_get ();
  if (obj == 0B) goto <D.31321>; else goto <D.31322>;
  <D.31321>:
  D.31323 = method->flags;
  D.31324 = (int) D.31323;
  D.31325 = D.31324 & 16;
  if (D.31325 == 0) goto <D.31326>; else goto <D.31327>;
  <D.31326>:
  D.31328 = BIT_FIELD_REF <*method, 8, 160>;
  D.31329 = D.31328 & 252;
  if (D.31329 == 0) goto <D.31330>; else goto <D.31331>;
  <D.31330>:
  monoeg_g_log (0B, 16, "Ignoring invocation of an instance method on a NULL instance.\n");
  D.31332 = 0B;
  return D.31332;
  <D.31331>:
  <D.31327>:
  <D.31322>:
  domain_info = domain->runtime_info;
  {
    int ret;

    D.31333 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31333);
    if (ret != 0) goto <D.31334>; else goto <D.31335>;
    <D.31334>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31335>:
    D.31336 = ret != 0;
    D.31337 = (long int) D.31336;
    D.31338 = __builtin_expect (D.31337, 0);
    if (D.31338 != 0) goto <D.31339>; else goto <D.31340>;
    <D.31339>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6436, "ret == 0");
    <D.31340>:
  }
  D.31341 = domain_info->runtime_invoke_hash;
  info = monoeg_g_hash_table_lookup (D.31341, method);
  {
    int ret;

    D.31333 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31333);
    if (ret != 0) goto <D.31342>; else goto <D.31343>;
    <D.31342>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31343>:
    D.31344 = ret != 0;
    D.31345 = (long int) D.31344;
    D.31346 = __builtin_expect (D.31345, 0);
    if (D.31346 != 0) goto <D.31347>; else goto <D.31348>;
    <D.31347>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6438, "ret == 0");
    <D.31348>:
  }
  if (info == 0B) goto <D.31349>; else goto <D.31350>;
  <D.31349>:
  D.31351 = mono_security_get_mode ();
  if (D.31351 == 1) goto <D.31352>; else goto <D.31353>;
  <D.31352>:
  D.31354 = method->klass;
  mono_class_setup_vtable (D.31354);
  D.31354 = method->klass;
  D.31355 = D.31354->exception_type;
  if (D.31355 != 0) goto <D.31356>; else goto <D.31357>;
  <D.31356>:
  if (exc != 0B) goto <D.31358>; else goto <D.31359>;
  <D.31358>:
  D.31354 = method->klass;
  D.31360 = mono_class_get_exception_for_failure (D.31354);
  *exc = D.31360;
  goto <D.31361>;
  <D.31359>:
  D.31354 = method->klass;
  D.31362 = mono_class_get_exception_for_failure (D.31354);
  mono_raise_exception (D.31362);
  <D.31361>:
  D.31332 = 0B;
  return D.31332;
  <D.31357>:
  <D.31353>:
  info = monoeg_malloc0 (24);
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  D.31354 = method->klass;
  D.31363 = mono_class_vtable_full (domain, D.31354, 1);
  info->vtable = D.31363;
  D.31364 = info->vtable;
  D.31365 = D.31364 == 0B;
  D.31366 = (long int) D.31365;
  D.31367 = __builtin_expect (D.31366, 0);
  if (D.31367 != 0) goto <D.31368>; else goto <D.31369>;
  <D.31368>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6460, "info->vtable");
  <D.31369>:
  callee = method;
  D.31354 = method->klass;
  D.31370 = D.31354->rank;
  if (D.31370 != 0) goto <D.31371>; else goto <D.31372>;
  <D.31371>:
  D.31373 = method->iflags;
  D.31374 = (unsigned int) D.31373;
  D.31375 = D.31374 & 4097;
  if (D.31375 == 4097) goto <D.31376>; else goto <D.31377>;
  <D.31376>:
  mono_aot_only.214 = mono_aot_only;
  if (mono_aot_only.214 != 0) goto <D.31379>; else goto <D.31380>;
  <D.31379>:
  {
    struct MonoMethod * wrapper;

    wrapper = mono_marshal_get_array_accessor_wrapper (method);
    invoke = mono_marshal_get_runtime_invoke (wrapper, 0);
    callee = wrapper;
  }
  goto <D.31381>;
  <D.31380>:
  callee = 0B;
  <D.31381>:
  <D.31377>:
  <D.31372>:
  if (callee != 0B) goto <D.31382>; else goto <D.31383>;
  <D.31382>:
  {
    struct MonoException * jit_ex;

    try
      {
        jit_ex = 0B;
        default_opt.215 = default_opt;
        D.31385 = mono_get_optimizations_for_method (callee, default_opt.215);
        D.31386 = mono_jit_compile_method_with_opt (callee, D.31385, &jit_ex);
        info->compiled_method = D.31386;
        D.31387 = info->compiled_method;
        if (D.31387 == 0B) goto <D.31388>; else goto <D.31389>;
        <D.31388>:
        monoeg_g_free (info);
        jit_ex.216 = jit_ex;
        D.31391 = jit_ex.216 == 0B;
        D.31392 = (long int) D.31391;
        D.31393 = __builtin_expect (D.31392, 0);
        if (D.31393 != 0) goto <D.31394>; else goto <D.31395>;
        <D.31394>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6489, "jit_ex");
        <D.31395>:
        if (exc != 0B) goto <D.31396>; else goto <D.31397>;
        <D.31396>:
        jit_ex.216 = jit_ex;
        *exc = jit_ex.216;
        D.31332 = 0B;
        return D.31332;
        <D.31397>:
        jit_ex.216 = jit_ex;
        mono_raise_exception (jit_ex.216);
        <D.31389>:
        D.31398 = mono_method_needs_static_rgctx_invoke (callee, 0);
        D.31387 = info->compiled_method;
        D.31399 = mini_add_method_trampoline (0B, callee, D.31387, D.31398, 0);
        info->compiled_method = D.31399;
      }
    finally
      {
        jit_ex = {CLOBBER};
      }
  }
  goto <D.31400>;
  <D.31383>:
  info->compiled_method = 0B;
  <D.31400>:
  D.31401 = info->dyn_call_info;
  if (D.31401 == 0B) goto <D.31402>; else goto <D.31403>;
  <D.31402>:
  D.31404 = mono_jit_compile_method (invoke);
  info->runtime_invoke = D.31404;
  <D.31403>:
  {
    int ret;

    D.31333 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31333);
    if (ret != 0) goto <D.31405>; else goto <D.31406>;
    <D.31405>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31406>:
    D.31407 = ret != 0;
    D.31408 = (long int) D.31407;
    D.31409 = __builtin_expect (D.31408, 0);
    if (D.31409 != 0) goto <D.31410>; else goto <D.31411>;
    <D.31410>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6579, "ret == 0");
    <D.31411>:
  }
  D.31341 = domain_info->runtime_invoke_hash;
  info2 = monoeg_g_hash_table_lookup (D.31341, method);
  if (info2 != 0B) goto <D.31412>; else goto <D.31413>;
  <D.31412>:
  monoeg_g_free (info);
  info = info2;
  goto <D.31414>;
  <D.31413>:
  D.31341 = domain_info->runtime_invoke_hash;
  monoeg_g_hash_table_insert_replace (D.31341, method, info, 0);
  <D.31414>:
  {
    int ret;

    D.31333 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31333);
    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", 6587, "ret == 0");
    <D.31421>:
  }
  <D.31350>:
  D.31422 = info->runtime_invoke;
  runtime_invoke = (struct MonoObject * (*<T3278>) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.31422;
  if (exc != 0B) goto <D.31423>; else goto <D.31424>;
  <D.31423>:
  D.31364 = info->vtable;
  D.31425 = mono_runtime_class_init_full (D.31364, 0);
  *exc = D.31425;
  D.31426 = *exc;
  if (D.31426 != 0B) goto <D.31427>; else goto <D.31428>;
  <D.31427>:
  D.31332 = 0B;
  return D.31332;
  <D.31428>:
  goto <D.31429>;
  <D.31424>:
  D.31364 = info->vtable;
  mono_runtime_class_init (D.31364);
  <D.31429>:
  if (exc != 0B) goto <D.31430>; else goto <D.31431>;
  <D.31430>:
  *exc = 0B;
  <D.31431>:
  D.31387 = info->compiled_method;
  D.31332 = runtime_invoke (obj, params, exc, D.31387);
  return D.31332;
}


mini_free_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.31435;
  struct GHashTable * D.31436;
  struct GHashTable * D.31439;
  struct GHashTable * D.31442;
  struct GHashTable * D.31445;
  struct GHashTable * D.31446;
  struct GHashTable * D.31447;
  struct GHashTable * D.31448;
  struct GHashTable * D.31449;
  struct GHashTable * D.31452;
  struct GHashTable * D.31453;
  struct GHashTable * D.31454;
  struct GHashTable * D.31455;
  void * D.31456;
  struct GHashTable * D.31459;
  void * D.31462;
  struct MonoJitDomainInfo * info;

  info = domain->runtime_info;
  D.31435 = info->jump_target_hash;
  monoeg_g_hash_table_foreach (D.31435, delete_jump_list, 0B);
  D.31435 = info->jump_target_hash;
  monoeg_g_hash_table_destroy (D.31435);
  D.31436 = info->jump_target_got_slot_hash;
  if (D.31436 != 0B) goto <D.31437>; else goto <D.31438>;
  <D.31437>:
  D.31436 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_foreach (D.31436, delete_got_slot_list, 0B);
  D.31436 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_destroy (D.31436);
  <D.31438>:
  D.31439 = info->dynamic_code_hash;
  if (D.31439 != 0B) goto <D.31440>; else goto <D.31441>;
  <D.31440>:
  D.31439 = info->dynamic_code_hash;
  monoeg_g_hash_table_foreach (D.31439, dynamic_method_info_free, 0B);
  D.31439 = info->dynamic_code_hash;
  monoeg_g_hash_table_destroy (D.31439);
  <D.31441>:
  D.31442 = info->method_code_hash;
  if (D.31442 != 0B) goto <D.31443>; else goto <D.31444>;
  <D.31443>:
  D.31442 = info->method_code_hash;
  monoeg_g_hash_table_destroy (D.31442);
  <D.31444>:
  D.31445 = info->class_init_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31445);
  D.31446 = info->jump_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31446);
  D.31447 = info->jit_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31447);
  D.31448 = info->delegate_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31448);
  D.31449 = info->static_rgctx_trampoline_hash;
  if (D.31449 != 0B) goto <D.31450>; else goto <D.31451>;
  <D.31450>:
  D.31449 = info->static_rgctx_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31449);
  <D.31451>:
  D.31452 = info->llvm_vcall_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31452);
  D.31453 = info->runtime_invoke_hash;
  monoeg_g_hash_table_destroy (D.31453);
  D.31454 = info->seq_points;
  monoeg_g_hash_table_destroy (D.31454);
  D.31455 = info->arch_seq_points;
  monoeg_g_hash_table_destroy (D.31455);
  D.31456 = info->agent_info;
  if (D.31456 != 0B) goto <D.31457>; else goto <D.31458>;
  <D.31457>:
  mono_debugger_agent_free_domain_info (domain);
  <D.31458>:
  D.31459 = info->gsharedvt_arg_tramp_hash;
  if (D.31459 != 0B) goto <D.31460>; else goto <D.31461>;
  <D.31460>:
  D.31459 = info->gsharedvt_arg_tramp_hash;
  monoeg_g_hash_table_destroy (D.31459);
  <D.31461>:
  D.31462 = domain->runtime_info;
  monoeg_g_free (D.31462);
  domain->runtime_info = 0B;
}


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

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

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


mini_create_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.31465;
  struct GHashTable * D.31466;
  struct GHashTable * D.31467;
  struct GHashTable * D.31468;
  struct GHashTable * D.31469;
  struct GHashTable * D.31470;
  struct GHashTable * D.31471;
  struct GHashTable * D.31472;
  struct GHashTable * D.31473;
  struct MonoJitDomainInfo * info;

  info = monoeg_malloc0 (196);
  D.31465 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->class_init_trampoline_hash = D.31465;
  D.31466 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jump_trampoline_hash = D.31466;
  D.31467 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jit_trampoline_hash = D.31467;
  D.31468 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->delegate_trampoline_hash = D.31468;
  D.31469 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->llvm_vcall_trampoline_hash = D.31469;
  D.31470 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, runtime_invoke_info_free);
  info->runtime_invoke_hash = D.31470;
  D.31471 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, seq_point_info_free);
  info->seq_points = D.31471;
  D.31472 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->arch_seq_points = D.31472;
  D.31473 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_hash = D.31473;
  domain->runtime_info = info;
}


seq_point_info_free (void * value)
{
  int * D.31474;
  int D.31475;
  int i;
  struct MonoSeqPointInfo * info;

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

    sp = &info->seq_points[i];
    D.31474 = sp->next;
    monoeg_g_free (D.31474);
  }
  i = i + 1;
  <D.26582>:
  D.31475 = info->len;
  if (D.31475 > i) goto <D.26581>; else goto <D.26583>;
  <D.26583>:
  monoeg_g_free (info);
}


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

  info = value;
  monoeg_g_free (info);
}


mono_jit_create_remoting_trampoline (struct MonoDomain * domain, struct MonoMethod * method, MonoRemotingTarget target)
{
  short unsigned int D.31476;
  int D.31477;
  int D.31478;
  struct MonoMethodSignature * D.31481;
  short unsigned int D.31482;
  void * D.31485;
  int D.31489;
  struct MonoMethodSignature * D.31491;
  unsigned char D.31492;
  unsigned char D.31493;
  struct MonoClass * D.31495;
  unsigned char D.31496;
  unsigned char D.31497;
  struct MonoClass * D.31499;
  struct MonoMethod * nm;
  guint8 * addr;

  addr = 0B;
  D.31476 = method->flags;
  D.31477 = (int) D.31476;
  D.31478 = D.31477 & 64;
  if (D.31478 != 0) goto <D.31479>; else goto <D.31480>;
  <D.31479>:
  D.31481 = mono_method_signature (method);
  D.31482 = D.31481->generic_param_count;
  if (D.31482 != 0) goto <D.31483>; else goto <D.31484>;
  <D.31483>:
  D.31485 = mono_create_specific_trampoline (method, 9, domain, 0B);
  return D.31485;
  <D.31484>:
  <D.31480>:
  D.31476 = method->flags;
  D.31477 = (int) D.31476;
  D.31489 = D.31477 & 1024;
  if (D.31489 != 0) goto <D.31486>; else goto <D.31490>;
  <D.31490>:
  D.31491 = mono_method_signature (method);
  D.31492 = BIT_FIELD_REF <*D.31491, 8, 80>;
  D.31493 = D.31492 & 64;
  if (D.31493 != 0) goto <D.31494>; else goto <D.31487>;
  <D.31494>:
  D.31495 = method->klass;
  D.31496 = BIT_FIELD_REF <*D.31495, 8, 176>;
  D.31497 = D.31496 & 64;
  if (D.31497 != 0) goto <D.31486>; else goto <D.31498>;
  <D.31498>:
  D.31495 = method->klass;
  D.31499 = mono_defaults.object_class;
  if (D.31495 == D.31499) goto <D.31486>; else goto <D.31487>;
  <D.31486>:
  nm = mono_marshal_get_remoting_invoke_for_target (method, target);
  addr = mono_compile_method (nm);
  goto <D.31488>;
  <D.31487>:
  addr = mono_compile_method (method);
  <D.31488>:
  D.31485 = mono_get_addr_from_ftnptr (addr);
  return D.31485;
}


mono_jit_free_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  unsigned char D.31501;
  unsigned char D.31502;
  _Bool D.31503;
  long int D.31504;
  long int D.31505;
  union mono_mutex_t * D.31508;
  _Bool D.31511;
  long int D.31512;
  long int D.31513;
  _Bool D.31518;
  long int D.31519;
  long int D.31520;
  _Bool D.31527;
  long int D.31528;
  long int D.31529;
  void * D.31532;
  struct GHashTable * D.31533;
  struct MonoInternalHashTable * D.31534;
  struct GHashTable * D.31535;
  struct GHashTable * D.31536;
  struct GHashTable * D.31537;
  struct MonoJumpList * jlist.217;
  struct MonoJitInfo * D.31539;
  void * D.31540;
  int D.31543;
  sizetype D.31544;
  guint8 * D.31545;
  void * D.31548;
  struct GSList * D.31549;
  struct GSList * D.31550;
  int D.31551;
  _Bool D.31554;
  long int D.31555;
  long int D.31556;
  int D.31559;
  unsigned char D.31562;
  unsigned char D.31563;
  struct MonoClass * D.31566;
  struct MonoType * D.31567;
  const char * D.31568;
  struct MonoCodeManager * D.31571;
  struct MonoJitDynamicMethodInfo * ji;
  gboolean destroy;
  struct GHashTableIter iter;
  struct MonoJumpList * jlist;

  try
    {
      destroy = 1;
      D.31501 = BIT_FIELD_REF <*method, 8, 168>;
      D.31502 = D.31501 & 2;
      D.31503 = D.31502 == 0;
      D.31504 = (long int) D.31503;
      D.31505 = __builtin_expect (D.31504, 0);
      if (D.31505 != 0) goto <D.31506>; else goto <D.31507>;
      <D.31506>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6280, "method->dynamic");
      <D.31507>:
      {
        int ret;

        D.31508 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.31508);
        if (ret != 0) goto <D.31509>; else goto <D.31510>;
        <D.31509>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.31510>:
        D.31511 = ret != 0;
        D.31512 = (long int) D.31511;
        D.31513 = __builtin_expect (D.31512, 0);
        if (D.31513 != 0) goto <D.31514>; else goto <D.31515>;
        <D.31514>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6282, "ret == 0");
        <D.31515>:
      }
      ji = mono_dynamic_code_hash_lookup (domain, method);
      {
        int ret;

        D.31508 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.31508);
        if (ret != 0) goto <D.31516>; else goto <D.31517>;
        <D.31516>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.31517>:
        D.31518 = ret != 0;
        D.31519 = (long int) D.31518;
        D.31520 = __builtin_expect (D.31519, 0);
        if (D.31520 != 0) goto <D.31521>; else goto <D.31522>;
        <D.31521>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6284, "ret == 0");
        <D.31522>:
      }
      if (ji == 0B) goto <D.31523>; else goto <D.31524>;
      <D.31523>:
      return;
      <D.31524>:
      mono_debug_remove_method (method, domain);
      {
        int ret;

        D.31508 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.31508);
        if (ret != 0) goto <D.31525>; else goto <D.31526>;
        <D.31525>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.31526>:
        D.31527 = ret != 0;
        D.31528 = (long int) D.31527;
        D.31529 = __builtin_expect (D.31528, 0);
        if (D.31529 != 0) goto <D.31530>; else goto <D.31531>;
        <D.31530>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6291, "ret == 0");
        <D.31531>:
      }
      D.31532 = domain->runtime_info;
      D.31533 = MEM[(struct MonoJitDomainInfo *)D.31532].dynamic_code_hash;
      monoeg_g_hash_table_remove (D.31533, method);
      D.31534 = &domain->jit_code_hash;
      mono_internal_hash_table_remove (D.31534, method);
      D.31532 = domain->runtime_info;
      D.31535 = MEM[(struct MonoJitDomainInfo *)D.31532].jump_trampoline_hash;
      monoeg_g_hash_table_remove (D.31535, method);
      D.31532 = domain->runtime_info;
      D.31536 = MEM[(struct MonoJitDomainInfo *)D.31532].runtime_invoke_hash;
      monoeg_g_hash_table_remove (D.31536, method);
      D.31532 = domain->runtime_info;
      D.31537 = MEM[(struct MonoJitDomainInfo *)D.31532].jump_target_hash;
      monoeg_g_hash_table_iter_init (&iter, D.31537);
      goto <D.26268>;
      <D.26267>:
      {
        struct GSList * tmp;
        struct GSList * remove;

        remove = 0B;
        jlist.217 = jlist;
        tmp = jlist.217->list;
        goto <D.26262>;
        <D.26261>:
        {
          guint8 * ip;

          ip = tmp->data;
          D.31539 = ji->ji;
          D.31540 = D.31539->code_start;
          if (D.31540 <= ip) goto <D.31541>; else goto <D.31542>;
          <D.31541>:
          D.31539 = ji->ji;
          D.31540 = D.31539->code_start;
          D.31539 = ji->ji;
          D.31543 = D.31539->code_size;
          D.31544 = (sizetype) D.31543;
          D.31545 = D.31540 + D.31544;
          if (D.31545 > ip) goto <D.31546>; else goto <D.31547>;
          <D.31546>:
          remove = monoeg_g_slist_prepend (remove, tmp);
          <D.31547>:
          <D.31542>:
        }
        tmp = tmp->next;
        <D.26262>:
        if (tmp != 0B) goto <D.26261>; else goto <D.26263>;
        <D.26263>:
        tmp = remove;
        goto <D.26265>;
        <D.26264>:
        jlist.217 = jlist;
        D.31548 = tmp->data;
        jlist.217 = jlist;
        D.31549 = jlist.217->list;
        D.31550 = monoeg_g_slist_delete_link (D.31549, D.31548);
        jlist.217->list = D.31550;
        tmp = tmp->next;
        <D.26265>:
        if (tmp != 0B) goto <D.26264>; else goto <D.26266>;
        <D.26266>:
        monoeg_g_slist_free (remove);
      }
      <D.26268>:
      D.31551 = monoeg_g_hash_table_iter_next (&iter, 0B, &jlist);
      if (D.31551 != 0) goto <D.26267>; else goto <D.26269>;
      <D.26269>:
      {
        int ret;

        D.31508 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.31508);
        if (ret != 0) goto <D.31552>; else goto <D.31553>;
        <D.31552>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.31553>:
        D.31554 = ret != 0;
        D.31555 = (long int) D.31554;
        D.31556 = __builtin_expect (D.31555, 0);
        if (D.31556 != 0) goto <D.31557>; else goto <D.31558>;
        <D.31557>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6315, "ret == 0");
        <D.31558>:
      }
      D.31559 = debug_options.keep_delegates;
      if (D.31559 != 0) goto <D.31560>; else goto <D.31561>;
      <D.31560>:
      D.31562 = BIT_FIELD_REF <*method, 8, 160>;
      D.31563 = D.31562 & 124;
      if (D.31563 == 20) goto <D.31564>; else goto <D.31565>;
      <D.31564>:
      {
        char * type;
        char * type_and_method;

        D.31566 = method->klass;
        D.31567 = &D.31566->byval_arg;
        type = mono_type_full_name (D.31567);
        D.31568 = method->name;
        type_and_method = monoeg_g_strdup_printf ("%s.%s", type, D.31568);
        monoeg_g_free (type);
        D.31539 = ji->ji;
        mono_arch_invalidate_method (D.31539, invalidated_delegate_trampoline, type_and_method);
        destroy = 0;
      }
      <D.31565>:
      <D.31561>:
      D.31539 = ji->ji;
      mono_jit_info_table_remove (domain, D.31539);
      if (destroy != 0) goto <D.31569>; else goto <D.31570>;
      <D.31569>:
      D.31571 = ji->code_mp;
      mono_code_manager_destroy (D.31571);
      <D.31570>:
      monoeg_g_free (ji);
    }
  finally
    {
      iter = {CLOBBER};
      jlist = {CLOBBER};
    }
}


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


mini_thread_cleanup (struct MonoInternalThread * thread)
{
  struct MonoInternalThread * D.31577;
  struct MonoLMF * D.31580;
  struct MonoJitTlsData * jit_tls;

  jit_tls = thread->jit_data;
  if (jit_tls != 0B) goto <D.31575>; else goto <D.31576>;
  <D.31575>:
  D.31577 = mono_thread_internal_current ();
  if (D.31577 == thread) goto <D.31578>; else goto <D.31579>;
  <D.31578>:
  mono_set_jit_tls (0B);
  <D.31579>:
  D.31580 = mono_get_lmf ();
  if (D.31580 != 0B) goto <D.31581>; else goto <D.31582>;
  <D.31581>:
  mono_set_lmf (0B);
  mono_set_lmf_addr (0B);
  <D.31582>:
  free_jit_tls_data (jit_tls);
  thread->jit_data = 0B;
  <D.31576>:
}


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

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


mini_get_imt_trampoline (int slot_index)
{
  void * D.31584;
  int D.31585;

  D.31585 = slot_index + -19;
  D.31584 = mini_get_vtable_trampoline (D.31585);
  return D.31584;
}


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

  D.31587 = descr;
  return D.31587;
}


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

  D.31589 = addr;
  return D.31589;
}


mini_parse_debug_options ()
{
  int D.26393;
  int iftmp.218;
  int D.26392;
  const char[14] * D.31596;
  unsigned char D.31597;
  int D.31598;
  unsigned char D.31599;
  int D.31600;
  _Bool D.31601;
  _Bool D.31602;
  _Bool D.31603;
  const unsigned char * D.31606;
  unsigned char D.31607;
  int D.31608;
  const unsigned char * D.31609;
  unsigned char D.31610;
  int D.31611;
  _Bool D.31612;
  _Bool D.31613;
  const unsigned char * D.31616;
  unsigned char D.31617;
  int D.31618;
  const unsigned char * D.31619;
  unsigned char D.31620;
  int D.31621;
  _Bool D.31622;
  _Bool D.31623;
  const unsigned char * D.31626;
  unsigned char D.31627;
  int D.31628;
  const unsigned char * D.31629;
  unsigned char D.31630;
  int D.31631;
  int D.26402;
  int iftmp.219;
  int D.26401;
  const char[15] * D.31639;
  unsigned char D.31640;
  int D.31641;
  unsigned char D.31642;
  int D.31643;
  _Bool D.31644;
  _Bool D.31645;
  _Bool D.31646;
  const unsigned char * D.31649;
  unsigned char D.31650;
  int D.31651;
  const unsigned char * D.31652;
  unsigned char D.31653;
  int D.31654;
  _Bool D.31655;
  _Bool D.31656;
  const unsigned char * D.31659;
  unsigned char D.31660;
  int D.31661;
  const unsigned char * D.31662;
  unsigned char D.31663;
  int D.31664;
  _Bool D.31665;
  _Bool D.31666;
  const unsigned char * D.31669;
  unsigned char D.31670;
  int D.31671;
  const unsigned char * D.31672;
  unsigned char D.31673;
  int D.31674;
  int D.26411;
  int iftmp.220;
  int D.26410;
  const char[27] * D.31682;
  unsigned char D.31683;
  int D.31684;
  unsigned char D.31685;
  int D.31686;
  _Bool D.31687;
  _Bool D.31688;
  _Bool D.31689;
  const unsigned char * D.31692;
  unsigned char D.31693;
  int D.31694;
  const unsigned char * D.31695;
  unsigned char D.31696;
  int D.31697;
  _Bool D.31698;
  _Bool D.31699;
  const unsigned char * D.31702;
  unsigned char D.31703;
  int D.31704;
  const unsigned char * D.31705;
  unsigned char D.31706;
  int D.31707;
  _Bool D.31708;
  _Bool D.31709;
  const unsigned char * D.31712;
  unsigned char D.31713;
  int D.31714;
  const unsigned char * D.31715;
  unsigned char D.31716;
  int D.31717;
  int D.26420;
  int iftmp.221;
  int D.26419;
  const char[24] * D.31725;
  unsigned char D.31726;
  int D.31727;
  unsigned char D.31728;
  int D.31729;
  _Bool D.31730;
  _Bool D.31731;
  _Bool D.31732;
  const unsigned char * D.31735;
  unsigned char D.31736;
  int D.31737;
  const unsigned char * D.31738;
  unsigned char D.31739;
  int D.31740;
  _Bool D.31741;
  _Bool D.31742;
  const unsigned char * D.31745;
  unsigned char D.31746;
  int D.31747;
  const unsigned char * D.31748;
  unsigned char D.31749;
  int D.31750;
  _Bool D.31751;
  _Bool D.31752;
  const unsigned char * D.31755;
  unsigned char D.31756;
  int D.31757;
  const unsigned char * D.31758;
  unsigned char D.31759;
  int D.31760;
  int D.26429;
  int iftmp.222;
  int D.26428;
  const char[20] * D.31768;
  unsigned char D.31769;
  int D.31770;
  unsigned char D.31771;
  int D.31772;
  _Bool D.31773;
  _Bool D.31774;
  _Bool D.31775;
  const unsigned char * D.31778;
  unsigned char D.31779;
  int D.31780;
  const unsigned char * D.31781;
  unsigned char D.31782;
  int D.31783;
  _Bool D.31784;
  _Bool D.31785;
  const unsigned char * D.31788;
  unsigned char D.31789;
  int D.31790;
  const unsigned char * D.31791;
  unsigned char D.31792;
  int D.31793;
  _Bool D.31794;
  _Bool D.31795;
  const unsigned char * D.31798;
  unsigned char D.31799;
  int D.31800;
  const unsigned char * D.31801;
  unsigned char D.31802;
  int D.31803;
  int D.26438;
  int iftmp.223;
  int D.26437;
  const char[17] * D.31811;
  unsigned char D.31812;
  int D.31813;
  unsigned char D.31814;
  int D.31815;
  _Bool D.31816;
  _Bool D.31817;
  _Bool D.31818;
  const unsigned char * D.31821;
  unsigned char D.31822;
  int D.31823;
  const unsigned char * D.31824;
  unsigned char D.31825;
  int D.31826;
  _Bool D.31827;
  _Bool D.31828;
  const unsigned char * D.31831;
  unsigned char D.31832;
  int D.31833;
  const unsigned char * D.31834;
  unsigned char D.31835;
  int D.31836;
  _Bool D.31837;
  _Bool D.31838;
  const unsigned char * D.31841;
  unsigned char D.31842;
  int D.31843;
  const unsigned char * D.31844;
  unsigned char D.31845;
  int D.31846;
  int D.26447;
  int iftmp.224;
  int D.26446;
  const char[19] * D.31854;
  unsigned char D.31855;
  int D.31856;
  unsigned char D.31857;
  int D.31858;
  _Bool D.31859;
  _Bool D.31860;
  _Bool D.31861;
  const unsigned char * D.31864;
  unsigned char D.31865;
  int D.31866;
  const unsigned char * D.31867;
  unsigned char D.31868;
  int D.31869;
  _Bool D.31870;
  _Bool D.31871;
  const unsigned char * D.31874;
  unsigned char D.31875;
  int D.31876;
  const unsigned char * D.31877;
  unsigned char D.31878;
  int D.31879;
  _Bool D.31880;
  _Bool D.31881;
  const unsigned char * D.31884;
  unsigned char D.31885;
  int D.31886;
  const unsigned char * D.31887;
  unsigned char D.31888;
  int D.31889;
  int D.26456;
  int iftmp.225;
  int D.26455;
  const char[21] * D.31897;
  unsigned char D.31898;
  int D.31899;
  unsigned char D.31900;
  int D.31901;
  _Bool D.31902;
  _Bool D.31903;
  _Bool D.31904;
  const unsigned char * D.31907;
  unsigned char D.31908;
  int D.31909;
  const unsigned char * D.31910;
  unsigned char D.31911;
  int D.31912;
  _Bool D.31913;
  _Bool D.31914;
  const unsigned char * D.31917;
  unsigned char D.31918;
  int D.31919;
  const unsigned char * D.31920;
  unsigned char D.31921;
  int D.31922;
  _Bool D.31923;
  _Bool D.31924;
  const unsigned char * D.31927;
  unsigned char D.31928;
  int D.31929;
  const unsigned char * D.31930;
  unsigned char D.31931;
  int D.31932;
  int D.26465;
  int iftmp.226;
  int D.26464;
  const char[18] * D.31940;
  unsigned char D.31941;
  int D.31942;
  unsigned char D.31943;
  int D.31944;
  _Bool D.31945;
  _Bool D.31946;
  _Bool D.31947;
  const unsigned char * D.31950;
  unsigned char D.31951;
  int D.31952;
  const unsigned char * D.31953;
  unsigned char D.31954;
  int D.31955;
  _Bool D.31956;
  _Bool D.31957;
  const unsigned char * D.31960;
  unsigned char D.31961;
  int D.31962;
  const unsigned char * D.31963;
  unsigned char D.31964;
  int D.31965;
  _Bool D.31966;
  _Bool D.31967;
  const unsigned char * D.31970;
  unsigned char D.31971;
  int D.31972;
  const unsigned char * D.31973;
  unsigned char D.31974;
  int D.31975;
  int D.26474;
  int iftmp.227;
  int D.26473;
  const char[19] * D.31983;
  unsigned char D.31984;
  int D.31985;
  unsigned char D.31986;
  int D.31987;
  _Bool D.31988;
  _Bool D.31989;
  _Bool D.31990;
  const unsigned char * D.31993;
  unsigned char D.31994;
  int D.31995;
  const unsigned char * D.31996;
  unsigned char D.31997;
  int D.31998;
  _Bool D.31999;
  _Bool D.32000;
  const unsigned char * D.32003;
  unsigned char D.32004;
  int D.32005;
  const unsigned char * D.32006;
  unsigned char D.32007;
  int D.32008;
  _Bool D.32009;
  _Bool D.32010;
  const unsigned char * D.32013;
  unsigned char D.32014;
  int D.32015;
  const unsigned char * D.32016;
  unsigned char D.32017;
  int D.32018;
  int D.26483;
  int iftmp.228;
  int D.26482;
  const char[4] * D.32026;
  unsigned char D.32027;
  int D.32028;
  unsigned char D.32029;
  int D.32030;
  _Bool D.32031;
  _Bool D.32032;
  _Bool D.32033;
  const unsigned char * D.32036;
  unsigned char D.32037;
  int D.32038;
  const unsigned char * D.32039;
  unsigned char D.32040;
  int D.32041;
  _Bool D.32042;
  _Bool D.32043;
  const unsigned char * D.32046;
  unsigned char D.32047;
  int D.32048;
  const unsigned char * D.32049;
  unsigned char D.32050;
  int D.32051;
  _Bool D.32052;
  _Bool D.32053;
  const unsigned char * D.32056;
  unsigned char D.32057;
  int D.32058;
  const unsigned char * D.32059;
  unsigned char D.32060;
  int D.32061;
  int D.26492;
  int iftmp.229;
  int D.26491;
  const char[21] * D.32069;
  unsigned char D.32070;
  int D.32071;
  unsigned char D.32072;
  int D.32073;
  _Bool D.32074;
  _Bool D.32075;
  _Bool D.32076;
  const unsigned char * D.32079;
  unsigned char D.32080;
  int D.32081;
  const unsigned char * D.32082;
  unsigned char D.32083;
  int D.32084;
  _Bool D.32085;
  _Bool D.32086;
  const unsigned char * D.32089;
  unsigned char D.32090;
  int D.32091;
  const unsigned char * D.32092;
  unsigned char D.32093;
  int D.32094;
  _Bool D.32095;
  _Bool D.32096;
  const unsigned char * D.32099;
  unsigned char D.32100;
  int D.32101;
  const unsigned char * D.32102;
  unsigned char D.32103;
  int D.32104;
  int D.26501;
  int iftmp.230;
  int D.26500;
  const char[15] * D.32112;
  unsigned char D.32113;
  int D.32114;
  unsigned char D.32115;
  int D.32116;
  _Bool D.32117;
  _Bool D.32118;
  _Bool D.32119;
  const unsigned char * D.32122;
  unsigned char D.32123;
  int D.32124;
  const unsigned char * D.32125;
  unsigned char D.32126;
  int D.32127;
  _Bool D.32128;
  _Bool D.32129;
  const unsigned char * D.32132;
  unsigned char D.32133;
  int D.32134;
  const unsigned char * D.32135;
  unsigned char D.32136;
  int D.32137;
  _Bool D.32138;
  _Bool D.32139;
  const unsigned char * D.32142;
  unsigned char D.32143;
  int D.32144;
  const unsigned char * D.32145;
  unsigned char D.32146;
  int D.32147;
  int D.26510;
  int iftmp.231;
  int D.26509;
  const char[12] * D.32155;
  unsigned char D.32156;
  int D.32157;
  unsigned char D.32158;
  int D.32159;
  _Bool D.32160;
  _Bool D.32161;
  _Bool D.32162;
  const unsigned char * D.32165;
  unsigned char D.32166;
  int D.32167;
  const unsigned char * D.32168;
  unsigned char D.32169;
  int D.32170;
  _Bool D.32171;
  _Bool D.32172;
  const unsigned char * D.32175;
  unsigned char D.32176;
  int D.32177;
  const unsigned char * D.32178;
  unsigned char D.32179;
  int D.32180;
  _Bool D.32181;
  _Bool D.32182;
  const unsigned char * D.32185;
  unsigned char D.32186;
  int D.32187;
  const unsigned char * D.32188;
  unsigned char D.32189;
  int D.32190;
  int D.26519;
  int iftmp.232;
  int D.26518;
  const char[6] * D.32198;
  unsigned char D.32199;
  int D.32200;
  unsigned char D.32201;
  int D.32202;
  _Bool D.32203;
  _Bool D.32204;
  _Bool D.32205;
  const unsigned char * D.32208;
  unsigned char D.32209;
  int D.32210;
  const unsigned char * D.32211;
  unsigned char D.32212;
  int D.32213;
  _Bool D.32214;
  _Bool D.32215;
  const unsigned char * D.32218;
  unsigned char D.32219;
  int D.32220;
  const unsigned char * D.32221;
  unsigned char D.32222;
  int D.32223;
  _Bool D.32224;
  _Bool D.32225;
  const unsigned char * D.32228;
  unsigned char D.32229;
  int D.32230;
  const unsigned char * D.32231;
  unsigned char D.32232;
  int D.32233;
  int D.26528;
  int iftmp.233;
  int D.26527;
  const char[17] * D.32241;
  unsigned char D.32242;
  int D.32243;
  unsigned char D.32244;
  int D.32245;
  _Bool D.32246;
  _Bool D.32247;
  _Bool D.32248;
  const unsigned char * D.32251;
  unsigned char D.32252;
  int D.32253;
  const unsigned char * D.32254;
  unsigned char D.32255;
  int D.32256;
  _Bool D.32257;
  _Bool D.32258;
  const unsigned char * D.32261;
  unsigned char D.32262;
  int D.32263;
  const unsigned char * D.32264;
  unsigned char D.32265;
  int D.32266;
  _Bool D.32267;
  _Bool D.32268;
  const unsigned char * D.32271;
  unsigned char D.32272;
  int D.32273;
  const unsigned char * D.32274;
  unsigned char D.32275;
  int D.32276;
  struct _IO_FILE * stderr.234;
  gchar * D.32283;
  const char * options;
  gchar * * args;
  gchar * * ptr;

  options = monoeg_g_getenv ("MONO_DEBUG");
  if (options == 0B) goto <D.31591>; else goto <D.31592>;
  <D.31591>:
  return;
  <D.31592>:
  args = monoeg_g_strsplit (options, ",", -1);
  ptr = args;
  goto <D.26530>;
  <D.26529>:
  {
    const char * arg;

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

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

        __s2 = arg;
        D.31596 = "handle-sigint";
        D.31597 = MEM[(const unsigned char *)D.31596];
        D.31598 = (int) D.31597;
        D.31599 = *__s2;
        D.31600 = (int) D.31599;
        __result = D.31598 - D.31600;
        {
          D.31601 = __s2_len != 0;
          D.31602 = __result == 0;
          D.31603 = D.31601 & D.31602;
          if (D.31603 != 0) goto <D.31604>; else goto <D.31605>;
          <D.31604>:
          D.31606 = &MEM[(void *)"handle-sigint" + 1B];
          D.31607 = *D.31606;
          D.31608 = (int) D.31607;
          D.31609 = __s2 + 1;
          D.31610 = *D.31609;
          D.31611 = (int) D.31610;
          __result = D.31608 - D.31611;
          D.31612 = __s2_len > 1;
          D.31602 = __result == 0;
          D.31613 = D.31612 & D.31602;
          if (D.31613 != 0) goto <D.31614>; else goto <D.31615>;
          <D.31614>:
          D.31616 = &MEM[(void *)"handle-sigint" + 2B];
          D.31617 = *D.31616;
          D.31618 = (int) D.31617;
          D.31619 = __s2 + 2;
          D.31620 = *D.31619;
          D.31621 = (int) D.31620;
          __result = D.31618 - D.31621;
          D.31622 = __s2_len > 2;
          D.31602 = __result == 0;
          D.31623 = D.31622 & D.31602;
          if (D.31623 != 0) goto <D.31624>; else goto <D.31625>;
          <D.31624>:
          D.31626 = &MEM[(void *)"handle-sigint" + 3B];
          D.31627 = *D.31626;
          D.31628 = (int) D.31627;
          D.31629 = __s2 + 3;
          D.31630 = *D.31629;
          D.31631 = (int) D.31630;
          __result = D.31628 - D.31631;
          <D.31625>:
          <D.31615>:
          <D.31605>:
        }
        D.26392 = __result;
      }
      iftmp.218 = -D.26392;
      goto <D.31632>;
      <D.31595>:
      iftmp.218 = __builtin_strcmp (arg, "handle-sigint");
      <D.31632>:
      D.26393 = iftmp.218;
    }
    if (D.26393 == 0) goto <D.31633>; else goto <D.31634>;
    <D.31633>:
    debug_options.handle_sigint = 1;
    goto <D.31635>;
    <D.31634>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31639 = "keep-delegates";
        D.31640 = MEM[(const unsigned char *)D.31639];
        D.31641 = (int) D.31640;
        D.31642 = *__s2;
        D.31643 = (int) D.31642;
        __result = D.31641 - D.31643;
        {
          D.31644 = __s2_len != 0;
          D.31645 = __result == 0;
          D.31646 = D.31644 & D.31645;
          if (D.31646 != 0) goto <D.31647>; else goto <D.31648>;
          <D.31647>:
          D.31649 = &MEM[(void *)"keep-delegates" + 1B];
          D.31650 = *D.31649;
          D.31651 = (int) D.31650;
          D.31652 = __s2 + 1;
          D.31653 = *D.31652;
          D.31654 = (int) D.31653;
          __result = D.31651 - D.31654;
          D.31655 = __s2_len > 1;
          D.31645 = __result == 0;
          D.31656 = D.31655 & D.31645;
          if (D.31656 != 0) goto <D.31657>; else goto <D.31658>;
          <D.31657>:
          D.31659 = &MEM[(void *)"keep-delegates" + 2B];
          D.31660 = *D.31659;
          D.31661 = (int) D.31660;
          D.31662 = __s2 + 2;
          D.31663 = *D.31662;
          D.31664 = (int) D.31663;
          __result = D.31661 - D.31664;
          D.31665 = __s2_len > 2;
          D.31645 = __result == 0;
          D.31666 = D.31665 & D.31645;
          if (D.31666 != 0) goto <D.31667>; else goto <D.31668>;
          <D.31667>:
          D.31669 = &MEM[(void *)"keep-delegates" + 3B];
          D.31670 = *D.31669;
          D.31671 = (int) D.31670;
          D.31672 = __s2 + 3;
          D.31673 = *D.31672;
          D.31674 = (int) D.31673;
          __result = D.31671 - D.31674;
          <D.31668>:
          <D.31658>:
          <D.31648>:
        }
        D.26401 = __result;
      }
      iftmp.219 = -D.26401;
      goto <D.31675>;
      <D.31638>:
      iftmp.219 = __builtin_strcmp (arg, "keep-delegates");
      <D.31675>:
      D.26402 = iftmp.219;
    }
    if (D.26402 == 0) goto <D.31676>; else goto <D.31677>;
    <D.31676>:
    debug_options.keep_delegates = 1;
    goto <D.31678>;
    <D.31677>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31682 = "reverse-pinvoke-exceptions";
        D.31683 = MEM[(const unsigned char *)D.31682];
        D.31684 = (int) D.31683;
        D.31685 = *__s2;
        D.31686 = (int) D.31685;
        __result = D.31684 - D.31686;
        {
          D.31687 = __s2_len != 0;
          D.31688 = __result == 0;
          D.31689 = D.31687 & D.31688;
          if (D.31689 != 0) goto <D.31690>; else goto <D.31691>;
          <D.31690>:
          D.31692 = &MEM[(void *)"reverse-pinvoke-exceptions" + 1B];
          D.31693 = *D.31692;
          D.31694 = (int) D.31693;
          D.31695 = __s2 + 1;
          D.31696 = *D.31695;
          D.31697 = (int) D.31696;
          __result = D.31694 - D.31697;
          D.31698 = __s2_len > 1;
          D.31688 = __result == 0;
          D.31699 = D.31698 & D.31688;
          if (D.31699 != 0) goto <D.31700>; else goto <D.31701>;
          <D.31700>:
          D.31702 = &MEM[(void *)"reverse-pinvoke-exceptions" + 2B];
          D.31703 = *D.31702;
          D.31704 = (int) D.31703;
          D.31705 = __s2 + 2;
          D.31706 = *D.31705;
          D.31707 = (int) D.31706;
          __result = D.31704 - D.31707;
          D.31708 = __s2_len > 2;
          D.31688 = __result == 0;
          D.31709 = D.31708 & D.31688;
          if (D.31709 != 0) goto <D.31710>; else goto <D.31711>;
          <D.31710>:
          D.31712 = &MEM[(void *)"reverse-pinvoke-exceptions" + 3B];
          D.31713 = *D.31712;
          D.31714 = (int) D.31713;
          D.31715 = __s2 + 3;
          D.31716 = *D.31715;
          D.31717 = (int) D.31716;
          __result = D.31714 - D.31717;
          <D.31711>:
          <D.31701>:
          <D.31691>:
        }
        D.26410 = __result;
      }
      iftmp.220 = -D.26410;
      goto <D.31718>;
      <D.31681>:
      iftmp.220 = __builtin_strcmp (arg, "reverse-pinvoke-exceptions");
      <D.31718>:
      D.26411 = iftmp.220;
    }
    if (D.26411 == 0) goto <D.31719>; else goto <D.31720>;
    <D.31719>:
    debug_options.reverse_pinvoke_exceptions = 1;
    goto <D.31721>;
    <D.31720>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31725 = "collect-pagefault-stats";
        D.31726 = MEM[(const unsigned char *)D.31725];
        D.31727 = (int) D.31726;
        D.31728 = *__s2;
        D.31729 = (int) D.31728;
        __result = D.31727 - D.31729;
        {
          D.31730 = __s2_len != 0;
          D.31731 = __result == 0;
          D.31732 = D.31730 & D.31731;
          if (D.31732 != 0) goto <D.31733>; else goto <D.31734>;
          <D.31733>:
          D.31735 = &MEM[(void *)"collect-pagefault-stats" + 1B];
          D.31736 = *D.31735;
          D.31737 = (int) D.31736;
          D.31738 = __s2 + 1;
          D.31739 = *D.31738;
          D.31740 = (int) D.31739;
          __result = D.31737 - D.31740;
          D.31741 = __s2_len > 1;
          D.31731 = __result == 0;
          D.31742 = D.31741 & D.31731;
          if (D.31742 != 0) goto <D.31743>; else goto <D.31744>;
          <D.31743>:
          D.31745 = &MEM[(void *)"collect-pagefault-stats" + 2B];
          D.31746 = *D.31745;
          D.31747 = (int) D.31746;
          D.31748 = __s2 + 2;
          D.31749 = *D.31748;
          D.31750 = (int) D.31749;
          __result = D.31747 - D.31750;
          D.31751 = __s2_len > 2;
          D.31731 = __result == 0;
          D.31752 = D.31751 & D.31731;
          if (D.31752 != 0) goto <D.31753>; else goto <D.31754>;
          <D.31753>:
          D.31755 = &MEM[(void *)"collect-pagefault-stats" + 3B];
          D.31756 = *D.31755;
          D.31757 = (int) D.31756;
          D.31758 = __s2 + 3;
          D.31759 = *D.31758;
          D.31760 = (int) D.31759;
          __result = D.31757 - D.31760;
          <D.31754>:
          <D.31744>:
          <D.31734>:
        }
        D.26419 = __result;
      }
      iftmp.221 = -D.26419;
      goto <D.31761>;
      <D.31724>:
      iftmp.221 = __builtin_strcmp (arg, "collect-pagefault-stats");
      <D.31761>:
      D.26420 = iftmp.221;
    }
    if (D.26420 == 0) goto <D.31762>; else goto <D.31763>;
    <D.31762>:
    debug_options.collect_pagefault_stats = 1;
    goto <D.31764>;
    <D.31763>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31768 = "break-on-unverified";
        D.31769 = MEM[(const unsigned char *)D.31768];
        D.31770 = (int) D.31769;
        D.31771 = *__s2;
        D.31772 = (int) D.31771;
        __result = D.31770 - D.31772;
        {
          D.31773 = __s2_len != 0;
          D.31774 = __result == 0;
          D.31775 = D.31773 & D.31774;
          if (D.31775 != 0) goto <D.31776>; else goto <D.31777>;
          <D.31776>:
          D.31778 = &MEM[(void *)"break-on-unverified" + 1B];
          D.31779 = *D.31778;
          D.31780 = (int) D.31779;
          D.31781 = __s2 + 1;
          D.31782 = *D.31781;
          D.31783 = (int) D.31782;
          __result = D.31780 - D.31783;
          D.31784 = __s2_len > 1;
          D.31774 = __result == 0;
          D.31785 = D.31784 & D.31774;
          if (D.31785 != 0) goto <D.31786>; else goto <D.31787>;
          <D.31786>:
          D.31788 = &MEM[(void *)"break-on-unverified" + 2B];
          D.31789 = *D.31788;
          D.31790 = (int) D.31789;
          D.31791 = __s2 + 2;
          D.31792 = *D.31791;
          D.31793 = (int) D.31792;
          __result = D.31790 - D.31793;
          D.31794 = __s2_len > 2;
          D.31774 = __result == 0;
          D.31795 = D.31794 & D.31774;
          if (D.31795 != 0) goto <D.31796>; else goto <D.31797>;
          <D.31796>:
          D.31798 = &MEM[(void *)"break-on-unverified" + 3B];
          D.31799 = *D.31798;
          D.31800 = (int) D.31799;
          D.31801 = __s2 + 3;
          D.31802 = *D.31801;
          D.31803 = (int) D.31802;
          __result = D.31800 - D.31803;
          <D.31797>:
          <D.31787>:
          <D.31777>:
        }
        D.26428 = __result;
      }
      iftmp.222 = -D.26428;
      goto <D.31804>;
      <D.31767>:
      iftmp.222 = __builtin_strcmp (arg, "break-on-unverified");
      <D.31804>:
      D.26429 = iftmp.222;
    }
    if (D.26429 == 0) goto <D.31805>; else goto <D.31806>;
    <D.31805>:
    debug_options.break_on_unverified = 1;
    goto <D.31807>;
    <D.31806>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31811 = "no-gdb-backtrace";
        D.31812 = MEM[(const unsigned char *)D.31811];
        D.31813 = (int) D.31812;
        D.31814 = *__s2;
        D.31815 = (int) D.31814;
        __result = D.31813 - D.31815;
        {
          D.31816 = __s2_len != 0;
          D.31817 = __result == 0;
          D.31818 = D.31816 & D.31817;
          if (D.31818 != 0) goto <D.31819>; else goto <D.31820>;
          <D.31819>:
          D.31821 = &MEM[(void *)"no-gdb-backtrace" + 1B];
          D.31822 = *D.31821;
          D.31823 = (int) D.31822;
          D.31824 = __s2 + 1;
          D.31825 = *D.31824;
          D.31826 = (int) D.31825;
          __result = D.31823 - D.31826;
          D.31827 = __s2_len > 1;
          D.31817 = __result == 0;
          D.31828 = D.31827 & D.31817;
          if (D.31828 != 0) goto <D.31829>; else goto <D.31830>;
          <D.31829>:
          D.31831 = &MEM[(void *)"no-gdb-backtrace" + 2B];
          D.31832 = *D.31831;
          D.31833 = (int) D.31832;
          D.31834 = __s2 + 2;
          D.31835 = *D.31834;
          D.31836 = (int) D.31835;
          __result = D.31833 - D.31836;
          D.31837 = __s2_len > 2;
          D.31817 = __result == 0;
          D.31838 = D.31837 & D.31817;
          if (D.31838 != 0) goto <D.31839>; else goto <D.31840>;
          <D.31839>:
          D.31841 = &MEM[(void *)"no-gdb-backtrace" + 3B];
          D.31842 = *D.31841;
          D.31843 = (int) D.31842;
          D.31844 = __s2 + 3;
          D.31845 = *D.31844;
          D.31846 = (int) D.31845;
          __result = D.31843 - D.31846;
          <D.31840>:
          <D.31830>:
          <D.31820>:
        }
        D.26437 = __result;
      }
      iftmp.223 = -D.26437;
      goto <D.31847>;
      <D.31810>:
      iftmp.223 = __builtin_strcmp (arg, "no-gdb-backtrace");
      <D.31847>:
      D.26438 = iftmp.223;
    }
    if (D.26438 == 0) goto <D.31848>; else goto <D.31849>;
    <D.31848>:
    debug_options.no_gdb_backtrace = 1;
    goto <D.31850>;
    <D.31849>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31854 = "suspend-on-sigsegv";
        D.31855 = MEM[(const unsigned char *)D.31854];
        D.31856 = (int) D.31855;
        D.31857 = *__s2;
        D.31858 = (int) D.31857;
        __result = D.31856 - D.31858;
        {
          D.31859 = __s2_len != 0;
          D.31860 = __result == 0;
          D.31861 = D.31859 & D.31860;
          if (D.31861 != 0) goto <D.31862>; else goto <D.31863>;
          <D.31862>:
          D.31864 = &MEM[(void *)"suspend-on-sigsegv" + 1B];
          D.31865 = *D.31864;
          D.31866 = (int) D.31865;
          D.31867 = __s2 + 1;
          D.31868 = *D.31867;
          D.31869 = (int) D.31868;
          __result = D.31866 - D.31869;
          D.31870 = __s2_len > 1;
          D.31860 = __result == 0;
          D.31871 = D.31870 & D.31860;
          if (D.31871 != 0) goto <D.31872>; else goto <D.31873>;
          <D.31872>:
          D.31874 = &MEM[(void *)"suspend-on-sigsegv" + 2B];
          D.31875 = *D.31874;
          D.31876 = (int) D.31875;
          D.31877 = __s2 + 2;
          D.31878 = *D.31877;
          D.31879 = (int) D.31878;
          __result = D.31876 - D.31879;
          D.31880 = __s2_len > 2;
          D.31860 = __result == 0;
          D.31881 = D.31880 & D.31860;
          if (D.31881 != 0) goto <D.31882>; else goto <D.31883>;
          <D.31882>:
          D.31884 = &MEM[(void *)"suspend-on-sigsegv" + 3B];
          D.31885 = *D.31884;
          D.31886 = (int) D.31885;
          D.31887 = __s2 + 3;
          D.31888 = *D.31887;
          D.31889 = (int) D.31888;
          __result = D.31886 - D.31889;
          <D.31883>:
          <D.31873>:
          <D.31863>:
        }
        D.26446 = __result;
      }
      iftmp.224 = -D.26446;
      goto <D.31890>;
      <D.31853>:
      iftmp.224 = __builtin_strcmp (arg, "suspend-on-sigsegv");
      <D.31890>:
      D.26447 = iftmp.224;
    }
    if (D.26447 == 0) goto <D.31891>; else goto <D.31892>;
    <D.31891>:
    debug_options.suspend_on_sigsegv = 1;
    goto <D.31893>;
    <D.31892>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31897 = "suspend-on-unhandled";
        D.31898 = MEM[(const unsigned char *)D.31897];
        D.31899 = (int) D.31898;
        D.31900 = *__s2;
        D.31901 = (int) D.31900;
        __result = D.31899 - D.31901;
        {
          D.31902 = __s2_len != 0;
          D.31903 = __result == 0;
          D.31904 = D.31902 & D.31903;
          if (D.31904 != 0) goto <D.31905>; else goto <D.31906>;
          <D.31905>:
          D.31907 = &MEM[(void *)"suspend-on-unhandled" + 1B];
          D.31908 = *D.31907;
          D.31909 = (int) D.31908;
          D.31910 = __s2 + 1;
          D.31911 = *D.31910;
          D.31912 = (int) D.31911;
          __result = D.31909 - D.31912;
          D.31913 = __s2_len > 1;
          D.31903 = __result == 0;
          D.31914 = D.31913 & D.31903;
          if (D.31914 != 0) goto <D.31915>; else goto <D.31916>;
          <D.31915>:
          D.31917 = &MEM[(void *)"suspend-on-unhandled" + 2B];
          D.31918 = *D.31917;
          D.31919 = (int) D.31918;
          D.31920 = __s2 + 2;
          D.31921 = *D.31920;
          D.31922 = (int) D.31921;
          __result = D.31919 - D.31922;
          D.31923 = __s2_len > 2;
          D.31903 = __result == 0;
          D.31924 = D.31923 & D.31903;
          if (D.31924 != 0) goto <D.31925>; else goto <D.31926>;
          <D.31925>:
          D.31927 = &MEM[(void *)"suspend-on-unhandled" + 3B];
          D.31928 = *D.31927;
          D.31929 = (int) D.31928;
          D.31930 = __s2 + 3;
          D.31931 = *D.31930;
          D.31932 = (int) D.31931;
          __result = D.31929 - D.31932;
          <D.31926>:
          <D.31916>:
          <D.31906>:
        }
        D.26455 = __result;
      }
      iftmp.225 = -D.26455;
      goto <D.31933>;
      <D.31896>:
      iftmp.225 = __builtin_strcmp (arg, "suspend-on-unhandled");
      <D.31933>:
      D.26456 = iftmp.225;
    }
    if (D.26456 == 0) goto <D.31934>; else goto <D.31935>;
    <D.31934>:
    debug_options.suspend_on_unhandled = 1;
    goto <D.31936>;
    <D.31935>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31940 = "dont-free-domains";
        D.31941 = MEM[(const unsigned char *)D.31940];
        D.31942 = (int) D.31941;
        D.31943 = *__s2;
        D.31944 = (int) D.31943;
        __result = D.31942 - D.31944;
        {
          D.31945 = __s2_len != 0;
          D.31946 = __result == 0;
          D.31947 = D.31945 & D.31946;
          if (D.31947 != 0) goto <D.31948>; else goto <D.31949>;
          <D.31948>:
          D.31950 = &MEM[(void *)"dont-free-domains" + 1B];
          D.31951 = *D.31950;
          D.31952 = (int) D.31951;
          D.31953 = __s2 + 1;
          D.31954 = *D.31953;
          D.31955 = (int) D.31954;
          __result = D.31952 - D.31955;
          D.31956 = __s2_len > 1;
          D.31946 = __result == 0;
          D.31957 = D.31956 & D.31946;
          if (D.31957 != 0) goto <D.31958>; else goto <D.31959>;
          <D.31958>:
          D.31960 = &MEM[(void *)"dont-free-domains" + 2B];
          D.31961 = *D.31960;
          D.31962 = (int) D.31961;
          D.31963 = __s2 + 2;
          D.31964 = *D.31963;
          D.31965 = (int) D.31964;
          __result = D.31962 - D.31965;
          D.31966 = __s2_len > 2;
          D.31946 = __result == 0;
          D.31967 = D.31966 & D.31946;
          if (D.31967 != 0) goto <D.31968>; else goto <D.31969>;
          <D.31968>:
          D.31970 = &MEM[(void *)"dont-free-domains" + 3B];
          D.31971 = *D.31970;
          D.31972 = (int) D.31971;
          D.31973 = __s2 + 3;
          D.31974 = *D.31973;
          D.31975 = (int) D.31974;
          __result = D.31972 - D.31975;
          <D.31969>:
          <D.31959>:
          <D.31949>:
        }
        D.26464 = __result;
      }
      iftmp.226 = -D.26464;
      goto <D.31976>;
      <D.31939>:
      iftmp.226 = __builtin_strcmp (arg, "dont-free-domains");
      <D.31976>:
      D.26465 = iftmp.226;
    }
    if (D.26465 == 0) goto <D.31977>; else goto <D.31978>;
    <D.31977>:
    mono_dont_free_domains = 1;
    goto <D.31979>;
    <D.31978>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31983 = "dyn-runtime-invoke";
        D.31984 = MEM[(const unsigned char *)D.31983];
        D.31985 = (int) D.31984;
        D.31986 = *__s2;
        D.31987 = (int) D.31986;
        __result = D.31985 - D.31987;
        {
          D.31988 = __s2_len != 0;
          D.31989 = __result == 0;
          D.31990 = D.31988 & D.31989;
          if (D.31990 != 0) goto <D.31991>; else goto <D.31992>;
          <D.31991>:
          D.31993 = &MEM[(void *)"dyn-runtime-invoke" + 1B];
          D.31994 = *D.31993;
          D.31995 = (int) D.31994;
          D.31996 = __s2 + 1;
          D.31997 = *D.31996;
          D.31998 = (int) D.31997;
          __result = D.31995 - D.31998;
          D.31999 = __s2_len > 1;
          D.31989 = __result == 0;
          D.32000 = D.31999 & D.31989;
          if (D.32000 != 0) goto <D.32001>; else goto <D.32002>;
          <D.32001>:
          D.32003 = &MEM[(void *)"dyn-runtime-invoke" + 2B];
          D.32004 = *D.32003;
          D.32005 = (int) D.32004;
          D.32006 = __s2 + 2;
          D.32007 = *D.32006;
          D.32008 = (int) D.32007;
          __result = D.32005 - D.32008;
          D.32009 = __s2_len > 2;
          D.31989 = __result == 0;
          D.32010 = D.32009 & D.31989;
          if (D.32010 != 0) goto <D.32011>; else goto <D.32012>;
          <D.32011>:
          D.32013 = &MEM[(void *)"dyn-runtime-invoke" + 3B];
          D.32014 = *D.32013;
          D.32015 = (int) D.32014;
          D.32016 = __s2 + 3;
          D.32017 = *D.32016;
          D.32018 = (int) D.32017;
          __result = D.32015 - D.32018;
          <D.32012>:
          <D.32002>:
          <D.31992>:
        }
        D.26473 = __result;
      }
      iftmp.227 = -D.26473;
      goto <D.32019>;
      <D.31982>:
      iftmp.227 = __builtin_strcmp (arg, "dyn-runtime-invoke");
      <D.32019>:
      D.26474 = iftmp.227;
    }
    if (D.26474 == 0) goto <D.32020>; else goto <D.32021>;
    <D.32020>:
    debug_options.dyn_runtime_invoke = 1;
    goto <D.32022>;
    <D.32021>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32026 = "gdb";
        D.32027 = MEM[(const unsigned char *)D.32026];
        D.32028 = (int) D.32027;
        D.32029 = *__s2;
        D.32030 = (int) D.32029;
        __result = D.32028 - D.32030;
        {
          D.32031 = __s2_len != 0;
          D.32032 = __result == 0;
          D.32033 = D.32031 & D.32032;
          if (D.32033 != 0) goto <D.32034>; else goto <D.32035>;
          <D.32034>:
          D.32036 = &MEM[(void *)"gdb" + 1B];
          D.32037 = *D.32036;
          D.32038 = (int) D.32037;
          D.32039 = __s2 + 1;
          D.32040 = *D.32039;
          D.32041 = (int) D.32040;
          __result = D.32038 - D.32041;
          D.32042 = __s2_len > 1;
          D.32032 = __result == 0;
          D.32043 = D.32042 & D.32032;
          if (D.32043 != 0) goto <D.32044>; else goto <D.32045>;
          <D.32044>:
          D.32046 = &MEM[(void *)"gdb" + 2B];
          D.32047 = *D.32046;
          D.32048 = (int) D.32047;
          D.32049 = __s2 + 2;
          D.32050 = *D.32049;
          D.32051 = (int) D.32050;
          __result = D.32048 - D.32051;
          D.32052 = __s2_len > 2;
          D.32032 = __result == 0;
          D.32053 = D.32052 & D.32032;
          if (D.32053 != 0) goto <D.32054>; else goto <D.32055>;
          <D.32054>:
          D.32056 = &MEM[(void *)"gdb" + 3B];
          D.32057 = *D.32056;
          D.32058 = (int) D.32057;
          D.32059 = __s2 + 3;
          D.32060 = *D.32059;
          D.32061 = (int) D.32060;
          __result = D.32058 - D.32061;
          <D.32055>:
          <D.32045>:
          <D.32035>:
        }
        D.26482 = __result;
      }
      iftmp.228 = -D.26482;
      goto <D.32062>;
      <D.32025>:
      iftmp.228 = __builtin_strcmp (arg, "gdb");
      <D.32062>:
      D.26483 = iftmp.228;
    }
    if (D.26483 == 0) goto <D.32063>; else goto <D.32064>;
    <D.32063>:
    debug_options.gdb = 1;
    goto <D.32065>;
    <D.32064>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32069 = "explicit-null-checks";
        D.32070 = MEM[(const unsigned char *)D.32069];
        D.32071 = (int) D.32070;
        D.32072 = *__s2;
        D.32073 = (int) D.32072;
        __result = D.32071 - D.32073;
        {
          D.32074 = __s2_len != 0;
          D.32075 = __result == 0;
          D.32076 = D.32074 & D.32075;
          if (D.32076 != 0) goto <D.32077>; else goto <D.32078>;
          <D.32077>:
          D.32079 = &MEM[(void *)"explicit-null-checks" + 1B];
          D.32080 = *D.32079;
          D.32081 = (int) D.32080;
          D.32082 = __s2 + 1;
          D.32083 = *D.32082;
          D.32084 = (int) D.32083;
          __result = D.32081 - D.32084;
          D.32085 = __s2_len > 1;
          D.32075 = __result == 0;
          D.32086 = D.32085 & D.32075;
          if (D.32086 != 0) goto <D.32087>; else goto <D.32088>;
          <D.32087>:
          D.32089 = &MEM[(void *)"explicit-null-checks" + 2B];
          D.32090 = *D.32089;
          D.32091 = (int) D.32090;
          D.32092 = __s2 + 2;
          D.32093 = *D.32092;
          D.32094 = (int) D.32093;
          __result = D.32091 - D.32094;
          D.32095 = __s2_len > 2;
          D.32075 = __result == 0;
          D.32096 = D.32095 & D.32075;
          if (D.32096 != 0) goto <D.32097>; else goto <D.32098>;
          <D.32097>:
          D.32099 = &MEM[(void *)"explicit-null-checks" + 3B];
          D.32100 = *D.32099;
          D.32101 = (int) D.32100;
          D.32102 = __s2 + 3;
          D.32103 = *D.32102;
          D.32104 = (int) D.32103;
          __result = D.32101 - D.32104;
          <D.32098>:
          <D.32088>:
          <D.32078>:
        }
        D.26491 = __result;
      }
      iftmp.229 = -D.26491;
      goto <D.32105>;
      <D.32068>:
      iftmp.229 = __builtin_strcmp (arg, "explicit-null-checks");
      <D.32105>:
      D.26492 = iftmp.229;
    }
    if (D.26492 == 0) goto <D.32106>; else goto <D.32107>;
    <D.32106>:
    debug_options.explicit_null_checks = 1;
    goto <D.32108>;
    <D.32107>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32112 = "gen-seq-points";
        D.32113 = MEM[(const unsigned char *)D.32112];
        D.32114 = (int) D.32113;
        D.32115 = *__s2;
        D.32116 = (int) D.32115;
        __result = D.32114 - D.32116;
        {
          D.32117 = __s2_len != 0;
          D.32118 = __result == 0;
          D.32119 = D.32117 & D.32118;
          if (D.32119 != 0) goto <D.32120>; else goto <D.32121>;
          <D.32120>:
          D.32122 = &MEM[(void *)"gen-seq-points" + 1B];
          D.32123 = *D.32122;
          D.32124 = (int) D.32123;
          D.32125 = __s2 + 1;
          D.32126 = *D.32125;
          D.32127 = (int) D.32126;
          __result = D.32124 - D.32127;
          D.32128 = __s2_len > 1;
          D.32118 = __result == 0;
          D.32129 = D.32128 & D.32118;
          if (D.32129 != 0) goto <D.32130>; else goto <D.32131>;
          <D.32130>:
          D.32132 = &MEM[(void *)"gen-seq-points" + 2B];
          D.32133 = *D.32132;
          D.32134 = (int) D.32133;
          D.32135 = __s2 + 2;
          D.32136 = *D.32135;
          D.32137 = (int) D.32136;
          __result = D.32134 - D.32137;
          D.32138 = __s2_len > 2;
          D.32118 = __result == 0;
          D.32139 = D.32138 & D.32118;
          if (D.32139 != 0) goto <D.32140>; else goto <D.32141>;
          <D.32140>:
          D.32142 = &MEM[(void *)"gen-seq-points" + 3B];
          D.32143 = *D.32142;
          D.32144 = (int) D.32143;
          D.32145 = __s2 + 3;
          D.32146 = *D.32145;
          D.32147 = (int) D.32146;
          __result = D.32144 - D.32147;
          <D.32141>:
          <D.32131>:
          <D.32121>:
        }
        D.26500 = __result;
      }
      iftmp.230 = -D.26500;
      goto <D.32148>;
      <D.32111>:
      iftmp.230 = __builtin_strcmp (arg, "gen-seq-points");
      <D.32148>:
      D.26501 = iftmp.230;
    }
    if (D.26501 == 0) goto <D.32149>; else goto <D.32150>;
    <D.32149>:
    debug_options.gen_seq_points = 1;
    goto <D.32151>;
    <D.32150>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32155 = "init-stacks";
        D.32156 = MEM[(const unsigned char *)D.32155];
        D.32157 = (int) D.32156;
        D.32158 = *__s2;
        D.32159 = (int) D.32158;
        __result = D.32157 - D.32159;
        {
          D.32160 = __s2_len != 0;
          D.32161 = __result == 0;
          D.32162 = D.32160 & D.32161;
          if (D.32162 != 0) goto <D.32163>; else goto <D.32164>;
          <D.32163>:
          D.32165 = &MEM[(void *)"init-stacks" + 1B];
          D.32166 = *D.32165;
          D.32167 = (int) D.32166;
          D.32168 = __s2 + 1;
          D.32169 = *D.32168;
          D.32170 = (int) D.32169;
          __result = D.32167 - D.32170;
          D.32171 = __s2_len > 1;
          D.32161 = __result == 0;
          D.32172 = D.32171 & D.32161;
          if (D.32172 != 0) goto <D.32173>; else goto <D.32174>;
          <D.32173>:
          D.32175 = &MEM[(void *)"init-stacks" + 2B];
          D.32176 = *D.32175;
          D.32177 = (int) D.32176;
          D.32178 = __s2 + 2;
          D.32179 = *D.32178;
          D.32180 = (int) D.32179;
          __result = D.32177 - D.32180;
          D.32181 = __s2_len > 2;
          D.32161 = __result == 0;
          D.32182 = D.32181 & D.32161;
          if (D.32182 != 0) goto <D.32183>; else goto <D.32184>;
          <D.32183>:
          D.32185 = &MEM[(void *)"init-stacks" + 3B];
          D.32186 = *D.32185;
          D.32187 = (int) D.32186;
          D.32188 = __s2 + 3;
          D.32189 = *D.32188;
          D.32190 = (int) D.32189;
          __result = D.32187 - D.32190;
          <D.32184>:
          <D.32174>:
          <D.32164>:
        }
        D.26509 = __result;
      }
      iftmp.231 = -D.26509;
      goto <D.32191>;
      <D.32154>:
      iftmp.231 = __builtin_strcmp (arg, "init-stacks");
      <D.32191>:
      D.26510 = iftmp.231;
    }
    if (D.26510 == 0) goto <D.32192>; else goto <D.32193>;
    <D.32192>:
    debug_options.init_stacks = 1;
    goto <D.32194>;
    <D.32193>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32198 = "casts";
        D.32199 = MEM[(const unsigned char *)D.32198];
        D.32200 = (int) D.32199;
        D.32201 = *__s2;
        D.32202 = (int) D.32201;
        __result = D.32200 - D.32202;
        {
          D.32203 = __s2_len != 0;
          D.32204 = __result == 0;
          D.32205 = D.32203 & D.32204;
          if (D.32205 != 0) goto <D.32206>; else goto <D.32207>;
          <D.32206>:
          D.32208 = &MEM[(void *)"casts" + 1B];
          D.32209 = *D.32208;
          D.32210 = (int) D.32209;
          D.32211 = __s2 + 1;
          D.32212 = *D.32211;
          D.32213 = (int) D.32212;
          __result = D.32210 - D.32213;
          D.32214 = __s2_len > 1;
          D.32204 = __result == 0;
          D.32215 = D.32214 & D.32204;
          if (D.32215 != 0) goto <D.32216>; else goto <D.32217>;
          <D.32216>:
          D.32218 = &MEM[(void *)"casts" + 2B];
          D.32219 = *D.32218;
          D.32220 = (int) D.32219;
          D.32221 = __s2 + 2;
          D.32222 = *D.32221;
          D.32223 = (int) D.32222;
          __result = D.32220 - D.32223;
          D.32224 = __s2_len > 2;
          D.32204 = __result == 0;
          D.32225 = D.32224 & D.32204;
          if (D.32225 != 0) goto <D.32226>; else goto <D.32227>;
          <D.32226>:
          D.32228 = &MEM[(void *)"casts" + 3B];
          D.32229 = *D.32228;
          D.32230 = (int) D.32229;
          D.32231 = __s2 + 3;
          D.32232 = *D.32231;
          D.32233 = (int) D.32232;
          __result = D.32230 - D.32233;
          <D.32227>:
          <D.32217>:
          <D.32207>:
        }
        D.26518 = __result;
      }
      iftmp.232 = -D.26518;
      goto <D.32234>;
      <D.32197>:
      iftmp.232 = __builtin_strcmp (arg, "casts");
      <D.32234>:
      D.26519 = iftmp.232;
    }
    if (D.26519 == 0) goto <D.32235>; else goto <D.32236>;
    <D.32235>:
    debug_options.better_cast_details = 1;
    goto <D.32237>;
    <D.32236>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32241 = "soft-breakpoints";
        D.32242 = MEM[(const unsigned char *)D.32241];
        D.32243 = (int) D.32242;
        D.32244 = *__s2;
        D.32245 = (int) D.32244;
        __result = D.32243 - D.32245;
        {
          D.32246 = __s2_len != 0;
          D.32247 = __result == 0;
          D.32248 = D.32246 & D.32247;
          if (D.32248 != 0) goto <D.32249>; else goto <D.32250>;
          <D.32249>:
          D.32251 = &MEM[(void *)"soft-breakpoints" + 1B];
          D.32252 = *D.32251;
          D.32253 = (int) D.32252;
          D.32254 = __s2 + 1;
          D.32255 = *D.32254;
          D.32256 = (int) D.32255;
          __result = D.32253 - D.32256;
          D.32257 = __s2_len > 1;
          D.32247 = __result == 0;
          D.32258 = D.32257 & D.32247;
          if (D.32258 != 0) goto <D.32259>; else goto <D.32260>;
          <D.32259>:
          D.32261 = &MEM[(void *)"soft-breakpoints" + 2B];
          D.32262 = *D.32261;
          D.32263 = (int) D.32262;
          D.32264 = __s2 + 2;
          D.32265 = *D.32264;
          D.32266 = (int) D.32265;
          __result = D.32263 - D.32266;
          D.32267 = __s2_len > 2;
          D.32247 = __result == 0;
          D.32268 = D.32267 & D.32247;
          if (D.32268 != 0) goto <D.32269>; else goto <D.32270>;
          <D.32269>:
          D.32271 = &MEM[(void *)"soft-breakpoints" + 3B];
          D.32272 = *D.32271;
          D.32273 = (int) D.32272;
          D.32274 = __s2 + 3;
          D.32275 = *D.32274;
          D.32276 = (int) D.32275;
          __result = D.32273 - D.32276;
          <D.32270>:
          <D.32260>:
          <D.32250>:
        }
        D.26527 = __result;
      }
      iftmp.233 = -D.26527;
      goto <D.32277>;
      <D.32240>:
      iftmp.233 = __builtin_strcmp (arg, "soft-breakpoints");
      <D.32277>:
      D.26528 = iftmp.233;
    }
    if (D.26528 == 0) goto <D.32278>; else goto <D.32279>;
    <D.32278>:
    debug_options.soft_breakpoints = 1;
    goto <D.32280>;
    <D.32279>:
    stderr.234 = stderr;
    fprintf (stderr.234, "Invalid option for the MONO_DEBUG env variable: %s\n", arg);
    stderr.234 = stderr;
    fprintf (stderr.234, "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.32280>:
    <D.32237>:
    <D.32194>:
    <D.32151>:
    <D.32108>:
    <D.32065>:
    <D.32022>:
    <D.31979>:
    <D.31936>:
    <D.31893>:
    <D.31850>:
    <D.31807>:
    <D.31764>:
    <D.31721>:
    <D.31678>:
    <D.31635>:
  }
  ptr = ptr + 4;
  <D.26530>:
  if (ptr != 0B) goto <D.32282>; else goto <D.26531>;
  <D.32282>:
  D.32283 = *ptr;
  if (D.32283 != 0B) goto <D.26529>; else goto <D.26531>;
  <D.26531>:
  monoeg_g_strfreev (args);
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.32285;
  void (*<Tbf>) (void *) destructor.235;
  int D.32287;
  _Bool D.32288;

  destructor.235 = (void (*<Tbf>) (void *)) destructor;
  D.32287 = pthread_key_create (key, destructor.235);
  D.32288 = D.32287 == 0;
  D.32285 = (int) D.32288;
  return D.32285;
}


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.32290>; else goto <D.32291>;
  <D.32290>:
  sig = mono_create_icall_signature (sigstr);
  goto <D.32292>;
  <D.32291>:
  sig = 0B;
  <D.32292>:
  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.32293;
  unsigned char D.32294;
  _Bool D.32295;
  long int D.32296;
  long int D.32297;
  short unsigned int D.32300;
  _Bool D.32301;
  long int D.32302;
  long int D.32303;
  short int emul_opcode_num.236;
  short int emul_opcode_alloced.237;
  int iftmp.238;
  short int D.32313;
  unsigned short D.32315;
  unsigned short emul_opcode_alloced.239;
  unsigned short D.32317;
  short int emul_opcode_alloced.240;
  unsigned int D.32319;
  unsigned int D.32320;
  struct MonoJitICallInfo * * emul_opcode_map.241;
  void * emul_opcode_map.242;
  unsigned int D.32323;
  short int * emul_opcode_opcodes.243;
  void * emul_opcode_opcodes.244;
  unsigned int D.32326;
  unsigned int D.32327;
  struct MonoJitICallInfo * * D.32328;
  unsigned int D.32329;
  short int * D.32330;
  short int D.32331;
  short int emul_opcode_num.245;
  unsigned short emul_opcode_num.246;
  unsigned short D.32334;
  short int emul_opcode_num.247;
  int D.32336;
  unsigned char D.32337;
  signed char D.32338;
  int D.32339;
  int D.32340;
  signed char D.32341;
  signed char D.32342;
  unsigned char D.32343;
  struct MonoJitICallInfo * info;
  struct MonoMethodSignature * sig;

  sig = mono_create_icall_signature (sigstr);
  D.32293 = BIT_FIELD_REF <*sig, 8, 80>;
  D.32294 = D.32293 & 64;
  D.32295 = D.32294 != 0;
  D.32296 = (long int) D.32295;
  D.32297 = __builtin_expect (D.32296, 0);
  if (D.32297 != 0) goto <D.32298>; else goto <D.32299>;
  <D.32298>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2373, "!sig->hasthis");
  <D.32299>:
  D.32300 = sig->param_count;
  D.32301 = D.32300 > 2;
  D.32302 = (long int) D.32301;
  D.32303 = __builtin_expect (D.32302, 0);
  if (D.32303 != 0) goto <D.32304>; else goto <D.32305>;
  <D.32304>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2374, "sig->param_count < 3");
  <D.32305>:
  info = mono_register_jit_icall_full (func, name, sig, no_throw, symbol);
  emul_opcode_num.236 = emul_opcode_num;
  emul_opcode_alloced.237 = emul_opcode_alloced;
  if (emul_opcode_num.236 >= emul_opcode_alloced.237) goto <D.32308>; else goto <D.32309>;
  <D.32308>:
  {
    int incr;

    emul_opcode_alloced.237 = emul_opcode_alloced;
    if (emul_opcode_alloced.237 != 0) goto <D.32311>; else goto <D.32312>;
    <D.32311>:
    emul_opcode_alloced.237 = emul_opcode_alloced;
    D.32313 = emul_opcode_alloced.237 / 2;
    iftmp.238 = (int) D.32313;
    goto <D.32314>;
    <D.32312>:
    iftmp.238 = 16;
    <D.32314>:
    incr = iftmp.238;
    D.32315 = (unsigned short) incr;
    emul_opcode_alloced.237 = emul_opcode_alloced;
    emul_opcode_alloced.239 = (unsigned short) emul_opcode_alloced.237;
    D.32317 = D.32315 + emul_opcode_alloced.239;
    emul_opcode_alloced.240 = (short int) D.32317;
    emul_opcode_alloced = emul_opcode_alloced.240;
    emul_opcode_alloced.237 = emul_opcode_alloced;
    D.32319 = (unsigned int) emul_opcode_alloced.237;
    D.32320 = D.32319 * 4;
    emul_opcode_map.241 = emul_opcode_map;
    emul_opcode_map.242 = monoeg_realloc (emul_opcode_map.241, D.32320);
    emul_opcode_map = emul_opcode_map.242;
    emul_opcode_alloced.237 = emul_opcode_alloced;
    D.32319 = (unsigned int) emul_opcode_alloced.237;
    D.32323 = D.32319 * 2;
    emul_opcode_opcodes.243 = emul_opcode_opcodes;
    emul_opcode_opcodes.244 = monoeg_realloc (emul_opcode_opcodes.243, D.32323);
    emul_opcode_opcodes = emul_opcode_opcodes.244;
  }
  <D.32309>:
  emul_opcode_map.241 = emul_opcode_map;
  emul_opcode_num.236 = emul_opcode_num;
  D.32326 = (unsigned int) emul_opcode_num.236;
  D.32327 = D.32326 * 4;
  D.32328 = emul_opcode_map.241 + D.32327;
  *D.32328 = info;
  emul_opcode_opcodes.243 = emul_opcode_opcodes;
  emul_opcode_num.236 = emul_opcode_num;
  D.32326 = (unsigned int) emul_opcode_num.236;
  D.32329 = D.32326 * 2;
  D.32330 = emul_opcode_opcodes.243 + D.32329;
  D.32331 = (short int) opcode;
  *D.32330 = D.32331;
  emul_opcode_num.236 = emul_opcode_num;
  emul_opcode_num.245 = emul_opcode_num.236;
  emul_opcode_num.246 = (unsigned short) emul_opcode_num.245;
  D.32334 = emul_opcode_num.246 + 1;
  emul_opcode_num.247 = (short int) D.32334;
  emul_opcode_num = emul_opcode_num.247;
  D.32336 = opcode >> 6;
  D.32336 = opcode >> 6;
  D.32337 = emul_opcode_hit_cache[D.32336];
  D.32338 = (signed char) D.32337;
  D.32339 = opcode & 7;
  D.32340 = 1 << D.32339;
  D.32341 = (signed char) D.32340;
  D.32342 = D.32338 | D.32341;
  D.32343 = (unsigned char) D.32342;
  emul_opcode_hit_cache[D.32336] = D.32343;
}


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

  if (sigstr != 0B) goto <D.32344>; else goto <D.32345>;
  <D.32344>:
  sig = mono_create_icall_signature (sigstr);
  goto <D.32346>;
  <D.32345>:
  sig = 0B;
  <D.32346>:
  if (save != 0) goto <D.32348>; else goto <D.32349>;
  <D.32348>:
  iftmp.248 = name;
  goto <D.32350>;
  <D.32349>:
  iftmp.248 = 0B;
  <D.32350>:
  mono_register_jit_icall_full (func, name, sig, save, iftmp.248);
}


mini_cleanup (struct MonoDomain * domain)
{
  unsigned int mono_jit_tls_id.249;
  void * D.32352;
  int mono_dont_free_global_codeman.250;
  struct MonoCodeManager * global_codeman.251;
  struct GHashTable * jit_icall_name_hash.252;
  struct MonoJitICallInfo * * emul_opcode_map.253;
  short int * emul_opcode_opcodes.254;
  void * * vtable_trampolines.255;
  struct _IO_FILE * stdout.256;
  struct MonoMethodDesc * mono_inject_async_exc_method.257;

  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.249 = mono_jit_tls_id;
  D.32352 = pthread_getspecific (mono_jit_tls_id.249);
  free_jit_tls_data (D.32352);
  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.250 = mono_dont_free_global_codeman;
  if (mono_dont_free_global_codeman.250 == 0) goto <D.32354>; else goto <D.32355>;
  <D.32354>:
  global_codeman.251 = global_codeman;
  mono_code_manager_destroy (global_codeman.251);
  <D.32355>:
  jit_icall_name_hash.252 = jit_icall_name_hash;
  monoeg_g_hash_table_destroy (jit_icall_name_hash.252);
  emul_opcode_map.253 = emul_opcode_map;
  monoeg_g_free (emul_opcode_map.253);
  emul_opcode_opcodes.254 = emul_opcode_opcodes;
  monoeg_g_free (emul_opcode_opcodes.254);
  vtable_trampolines.255 = vtable_trampolines;
  monoeg_g_free (vtable_trampolines.255);
  mono_arch_cleanup ();
  mono_generic_sharing_cleanup ();
  mono_cleanup ();
  mono_trace_cleanup ();
  stdout.256 = stdout;
  mono_counters_dump (-1, stdout.256);
  mono_inject_async_exc_method.257 = mono_inject_async_exc_method;
  if (mono_inject_async_exc_method.257 != 0B) goto <D.32363>; else goto <D.32364>;
  <D.32363>:
  mono_inject_async_exc_method.257 = mono_inject_async_exc_method;
  mono_method_desc_free (mono_inject_async_exc_method.257);
  <D.32364>:
  mono_jit_tls_id.249 = mono_jit_tls_id;
  mono_native_tls_free (mono_jit_tls_id.249);
  DeleteCriticalSection (&jit_mutex);
  DeleteCriticalSection (&mono_delegate_section);
  mono_code_manager_cleanup ();
}


print_jit_stats ()
{
  int D.32365;
  char * D.32368;
  int D.32369;
  double D.32370;
  double D.32371;
  char * D.32372;
  int D.32373;
  long unsigned int D.32374;
  long unsigned int D.32375;
  long unsigned int D.32376;
  long unsigned int D.32377;
  long unsigned int D.32378;
  long unsigned int D.32379;
  long unsigned int D.32380;
  struct MonoImage * D.32381;
  struct MonoMemPool * D.32382;
  unsigned int D.32383;
  long unsigned int D.32384;
  long unsigned int D.32385;
  int D.32386;
  long unsigned int D.32387;
  long unsigned int D.32388;
  long unsigned int D.32389;
  long unsigned int D.32390;
  long unsigned int D.32391;
  long unsigned int D.32392;
  long unsigned int D.32393;
  long unsigned int D.32394;
  long unsigned int D.32395;
  long unsigned int D.32396;
  long unsigned int D.32397;
  long unsigned int D.32398;
  long unsigned int D.32399;
  long unsigned int D.32400;
  long unsigned int D.32401;
  long unsigned int D.32402;
  long unsigned int D.32403;
  long unsigned int D.32404;
  long unsigned int D.32405;
  <unnamed type> D.32406;
  int D.32409;
  int D.32410;
  int D.32411;
  int D.32412;
  int D.32413;
  int D.32414;

  D.32365 = mono_jit_stats.enabled;
  if (D.32365 != 0) goto <D.32366>; else goto <D.32367>;
  <D.32366>:
  monoeg_g_print ("Mono Jit statistics\n");
  D.32368 = mono_jit_stats.max_ratio_method;
  D.32369 = mono_jit_stats.max_code_size_ratio;
  D.32370 = (double) D.32369;
  D.32371 = D.32370 / 1.0e+2;
  monoeg_g_print ("Max code size ratio:    %.2f (%s)\n", D.32371, D.32368);
  D.32372 = mono_jit_stats.biggest_method;
  D.32373 = mono_jit_stats.biggest_method_size;
  monoeg_g_print ("Biggest method:         %ld (%s)\n", D.32373, D.32372);
  D.32374 = mono_stats.delegate_creations;
  monoeg_g_print ("Delegates created:      %ld\n", D.32374);
  D.32375 = mono_stats.initialized_class_count;
  monoeg_g_print ("Initialized classes:    %ld\n", D.32375);
  D.32376 = mono_stats.used_class_count;
  monoeg_g_print ("Used classes:           %ld\n", D.32376);
  D.32377 = mono_stats.generic_vtable_count;
  monoeg_g_print ("Generic vtables:        %ld\n", D.32377);
  D.32378 = mono_stats.method_count;
  monoeg_g_print ("Methods:                %ld\n", D.32378);
  D.32379 = mono_stats.class_static_data_size;
  monoeg_g_print ("Static data size:       %ld\n", D.32379);
  D.32380 = mono_stats.class_vtable_size;
  monoeg_g_print ("VTable data size:       %ld\n", D.32380);
  D.32381 = mono_defaults.corlib;
  D.32382 = D.32381->mempool;
  D.32383 = mono_mempool_get_allocated (D.32382);
  monoeg_g_print ("Mscorlib mempool size:  %d\n", D.32383);
  D.32384 = mono_stats.generic_class_count;
  monoeg_g_print ("\nInitialized classes:    %ld\n", D.32384);
  D.32385 = mono_stats.inflated_type_count;
  monoeg_g_print ("Inflated types:         %ld\n", D.32385);
  D.32386 = mono_jit_stats.generic_virtual_invocations;
  monoeg_g_print ("Generics virtual invokes: %ld\n", D.32386);
  D.32387 = mono_stats.generics_sharable_methods;
  monoeg_g_print ("Sharable generic methods: %ld\n", D.32387);
  D.32388 = mono_stats.generics_unsharable_methods;
  monoeg_g_print ("Unsharable generic methods: %ld\n", D.32388);
  D.32389 = mono_stats.generics_shared_methods;
  monoeg_g_print ("Shared generic methods: %ld\n", D.32389);
  D.32390 = mono_stats.gsharedvt_methods;
  monoeg_g_print ("Shared vtype generic methods: %ld\n", D.32390);
  D.32391 = mono_stats.dynamic_code_alloc_count;
  monoeg_g_print ("Dynamic code allocs:    %ld\n", D.32391);
  D.32392 = mono_stats.dynamic_code_bytes_count;
  monoeg_g_print ("Dynamic code bytes:     %ld\n", D.32392);
  D.32393 = mono_stats.dynamic_code_frees_count;
  monoeg_g_print ("Dynamic code frees:     %ld\n", D.32393);
  D.32394 = mono_stats.imt_tables_size;
  monoeg_g_print ("IMT tables size:        %ld\n", D.32394);
  D.32395 = mono_stats.imt_number_of_tables;
  monoeg_g_print ("IMT number of tables:   %ld\n", D.32395);
  D.32396 = mono_stats.imt_number_of_methods;
  monoeg_g_print ("IMT number of methods:  %ld\n", D.32396);
  D.32397 = mono_stats.imt_used_slots;
  monoeg_g_print ("IMT used slots:         %ld\n", D.32397);
  D.32398 = mono_stats.imt_slots_with_collisions;
  monoeg_g_print ("IMT colliding slots:    %ld\n", D.32398);
  D.32399 = mono_stats.imt_max_collisions_in_slot;
  monoeg_g_print ("IMT max collisions:     %ld\n", D.32399);
  D.32400 = mono_stats.imt_method_count_when_max_collisions;
  monoeg_g_print ("IMT methods at max col: %ld\n", D.32400);
  D.32401 = mono_stats.imt_thunks_size;
  monoeg_g_print ("IMT thunks size:        %ld\n", D.32401);
  D.32402 = mono_stats.jit_info_table_insert_count;
  monoeg_g_print ("JIT info table inserts: %ld\n", D.32402);
  D.32403 = mono_stats.jit_info_table_remove_count;
  monoeg_g_print ("JIT info table removes: %ld\n", D.32403);
  D.32404 = mono_stats.jit_info_table_lookup_count;
  monoeg_g_print ("JIT info table lookups: %ld\n", D.32404);
  D.32405 = mono_stats.hazardous_pointer_count;
  monoeg_g_print ("Hazardous pointers:     %ld\n", D.32405);
  D.32406 = mono_security_get_mode ();
  if (D.32406 == 2) goto <D.32407>; else goto <D.32408>;
  <D.32407>:
  D.32409 = mono_jit_stats.cas_declsec_check;
  monoeg_g_print ("\nDecl security check   : %ld\n", D.32409);
  D.32410 = mono_jit_stats.cas_linkdemand;
  monoeg_g_print ("LinkDemand (user)     : %ld\n", D.32410);
  D.32411 = mono_jit_stats.cas_linkdemand_icall;
  monoeg_g_print ("LinkDemand (icall)    : %ld\n", D.32411);
  D.32412 = mono_jit_stats.cas_linkdemand_pinvoke;
  monoeg_g_print ("LinkDemand (pinvoke)  : %ld\n", D.32412);
  D.32413 = mono_jit_stats.cas_linkdemand_aptc;
  monoeg_g_print ("LinkDemand (aptc)     : %ld\n", D.32413);
  D.32414 = mono_jit_stats.cas_demand_generation;
  monoeg_g_print ("Demand (code gen)     : %ld\n", D.32414);
  <D.32408>:
  D.32368 = mono_jit_stats.max_ratio_method;
  monoeg_g_free (D.32368);
  mono_jit_stats.max_ratio_method = 0B;
  D.32372 = mono_jit_stats.biggest_method;
  monoeg_g_free (D.32372);
  mono_jit_stats.biggest_method = 0B;
  <D.32367>:
}


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.32415;
  unsigned int default_opt.258;
  unsigned int default_opt.259;

  D.32415 = ~opts;
  default_opt.258 = default_opt;
  default_opt.259 = D.32415 & default_opt.258;
  default_opt = default_opt.259;
}


mono_set_optimizations (guint32 opts)
{
  int iftmp.260;
  int mono_aot_only.261;
  unsigned int default_opt.262;
  unsigned int D.32425;

  default_opt = opts;
  default_opt_set = 1;
  mono_aot_only.261 = mono_aot_only;
  if (mono_aot_only.261 != 0) goto <D.32419>; else goto <D.32423>;
  <D.32423>:
  default_opt.262 = default_opt;
  D.32425 = default_opt.262 & 16777216;
  if (D.32425 != 0) goto <D.32419>; else goto <D.32420>;
  <D.32419>:
  iftmp.260 = 1;
  goto <D.32421>;
  <D.32420>:
  iftmp.260 = 0;
  <D.32421>:
  mono_set_generic_sharing_vt_supported (iftmp.260);
}


mono_set_verbose_level (guint32 level)
{
  int level.263;

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


mono_get_runtime_build_info ()
{
  const char * mono_build_date.264;
  char * D.32430;

  mono_build_date.264 = mono_build_date;
  if (mono_build_date.264 != 0B) goto <D.32428>; else goto <D.32429>;
  <D.32428>:
  mono_build_date.264 = mono_build_date;
  D.32430 = monoeg_g_strdup_printf ("%s (%s %s)", "3.2.8", "Debian 3.2.8+dfsg-10", mono_build_date.264);
  return D.32430;
  <D.32429>:
  D.32430 = monoeg_g_strdup_printf ("%s (%s)", "3.2.8", "Debian 3.2.8+dfsg-10");
  return D.32430;
}


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.32432;
  int mini_verbose.265;
  const char * D.32438;
  int D.32439;
  int D.32440;
  unsigned int D.32441;
  short unsigned int D.32442;
  int D.32443;
  int D.32444;
  int D.26640;
  int iftmp.266;
  int D.26639;
  const char[9] * D.32452;
  unsigned char D.32453;
  int D.32454;
  unsigned char D.32455;
  int D.32456;
  _Bool D.32457;
  _Bool D.32458;
  _Bool D.32459;
  const unsigned char * D.32462;
  unsigned char D.32463;
  int D.32464;
  const unsigned char * D.32465;
  unsigned char D.32466;
  int D.32467;
  _Bool D.32468;
  _Bool D.32469;
  const unsigned char * D.32472;
  unsigned char D.32473;
  int D.32474;
  const unsigned char * D.32475;
  unsigned char D.32476;
  int D.32477;
  _Bool D.32478;
  _Bool D.32479;
  const unsigned char * D.32482;
  unsigned char D.32483;
  int D.32484;
  const unsigned char * D.32485;
  unsigned char D.32486;
  int D.32487;
  const char * D.32489;
  struct MonoClass * D.32492;
  unsigned char D.32493;
  unsigned char D.32494;
  struct MonoMethodSignature * D.32497;
  unsigned char D.32498;
  unsigned char D.32499;
  int D.32502;
  struct MonoAssembly * * D.32503;
  unsigned int i.267;
  unsigned int D.32505;
  struct MonoAssembly * * D.32506;
  struct MonoAssembly * D.32507;
  int D.32510;
  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.32432 = monoeg_g_hash_table_lookup (assemblies, ass);
  if (D.32432 != 0B) goto <D.32433>; else goto <D.32434>;
  <D.32433>:
  return;
  <D.32434>:
  monoeg_g_hash_table_insert_replace (assemblies, ass, ass, 0);
  mini_verbose.265 = mini_verbose;
  if (mini_verbose.265 > 0) goto <D.32436>; else goto <D.32437>;
  <D.32436>:
  D.32438 = mono_image_get_filename (image);
  printf ("PRECOMPILE: %s.\n", D.32438);
  <D.32437>:
  i = 0;
  goto <D.26642>;
  <D.26641>:
  D.32439 = i + 1;
  D.32440 = D.32439 | 100663296;
  D.32441 = (unsigned int) D.32440;
  method = mono_get_method (image, D.32441, 0B);
  D.32442 = method->flags;
  D.32443 = (int) D.32442;
  D.32444 = D.32443 & 1024;
  if (D.32444 != 0) goto <D.32445>; else goto <D.32446>;
  <D.32445>:
  // predicted unlikely by continue predictor.
  goto <D.26630>;
  <D.32446>:
  count = count + 1;
  mini_verbose.265 = mini_verbose;
  if (mini_verbose.265 > 1) goto <D.32447>; else goto <D.32448>;
  <D.32447>:
  {
    char * desc;

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

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

      __s2 = method->name;
      D.32452 = "Finalize";
      D.32453 = MEM[(const unsigned char *)D.32452];
      D.32454 = (int) D.32453;
      D.32455 = *__s2;
      D.32456 = (int) D.32455;
      __result = D.32454 - D.32456;
      {
        D.32457 = __s2_len != 0;
        D.32458 = __result == 0;
        D.32459 = D.32457 & D.32458;
        if (D.32459 != 0) goto <D.32460>; else goto <D.32461>;
        <D.32460>:
        D.32462 = &MEM[(void *)"Finalize" + 1B];
        D.32463 = *D.32462;
        D.32464 = (int) D.32463;
        D.32465 = __s2 + 1;
        D.32466 = *D.32465;
        D.32467 = (int) D.32466;
        __result = D.32464 - D.32467;
        D.32468 = __s2_len > 1;
        D.32458 = __result == 0;
        D.32469 = D.32468 & D.32458;
        if (D.32469 != 0) goto <D.32470>; else goto <D.32471>;
        <D.32470>:
        D.32472 = &MEM[(void *)"Finalize" + 2B];
        D.32473 = *D.32472;
        D.32474 = (int) D.32473;
        D.32475 = __s2 + 2;
        D.32476 = *D.32475;
        D.32477 = (int) D.32476;
        __result = D.32474 - D.32477;
        D.32478 = __s2_len > 2;
        D.32458 = __result == 0;
        D.32479 = D.32478 & D.32458;
        if (D.32479 != 0) goto <D.32480>; else goto <D.32481>;
        <D.32480>:
        D.32482 = &MEM[(void *)"Finalize" + 3B];
        D.32483 = *D.32482;
        D.32484 = (int) D.32483;
        D.32485 = __s2 + 3;
        D.32486 = *D.32485;
        D.32487 = (int) D.32486;
        __result = D.32484 - D.32487;
        <D.32481>:
        <D.32471>:
        <D.32461>:
      }
      D.26639 = __result;
    }
    iftmp.266 = -D.26639;
    goto <D.32488>;
    <D.32451>:
    D.32489 = method->name;
    iftmp.266 = __builtin_strcmp (D.32489, "Finalize");
    <D.32488>:
    D.26640 = iftmp.266;
  }
  if (D.26640 == 0) goto <D.32490>; else goto <D.32491>;
  <D.32490>:
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  mono_compile_method (invoke);
  <D.32491>:
  D.32492 = method->klass;
  D.32493 = BIT_FIELD_REF <*D.32492, 8, 176>;
  D.32494 = D.32493 & 64;
  if (D.32494 != 0) goto <D.32495>; else goto <D.32496>;
  <D.32495>:
  D.32497 = mono_method_signature (method);
  D.32498 = BIT_FIELD_REF <*D.32497, 8, 80>;
  D.32499 = D.32498 & 64;
  if (D.32499 != 0) goto <D.32500>; else goto <D.32501>;
  <D.32500>:
  invoke = mono_marshal_get_remoting_invoke_with_check (method);
  mono_compile_method (invoke);
  <D.32501>:
  <D.32496>:
  <D.26630>:
  i = i + 1;
  <D.26642>:
  D.32502 = mono_image_get_table_rows (image, 6);
  if (D.32502 > i) goto <D.26641>; else goto <D.26643>;
  <D.26643>:
  i = 0;
  goto <D.26645>;
  <D.26644>:
  mono_assembly_load_reference (image, i);
  D.32503 = image->references;
  i.267 = (unsigned int) i;
  D.32505 = i.267 * 4;
  D.32506 = D.32503 + D.32505;
  D.32507 = *D.32506;
  if (D.32507 != 0B) goto <D.32508>; else goto <D.32509>;
  <D.32508>:
  D.32503 = image->references;
  i.267 = (unsigned int) i;
  D.32505 = i.267 * 4;
  D.32506 = D.32503 + D.32505;
  D.32507 = *D.32506;
  mono_precompile_assembly (D.32507, assemblies);
  <D.32509>:
  i = i + 1;
  <D.26645>:
  D.32510 = mono_image_get_table_rows (image, 35);
  if (D.32510 > i) goto <D.26644>; else goto <D.26646>;
  <D.26646>:
}


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

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


mono_cfg_add_try_hole (struct MonoCompile * cfg, struct MonoExceptionClause * clause, guint8 * start, struct MonoBasicBlock * bb)
{
  struct MonoMemPool * D.32514;
  int start.268;
  unsigned char * D.32516;
  int D.32517;
  int D.32518;
  struct GSList * D.32519;
  struct GSList * D.32520;
  struct TryBlockHole * hole;

  D.32514 = cfg->mempool;
  hole = mono_mempool_alloc (D.32514, 12);
  hole->clause = clause;
  start.268 = (int) start;
  D.32516 = cfg->native_code;
  D.32517 = (int) D.32516;
  D.32518 = start.268 - D.32517;
  hole->start_offset = D.32518;
  hole->basic_block = bb;
  D.32519 = cfg->try_block_holes;
  D.32514 = cfg->mempool;
  D.32520 = g_slist_append_mempool (D.32514, D.32519, hole);
  cfg->try_block_holes = D.32520;
}


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

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


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

  D.32522 = 0;
  return D.32522;
}


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

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


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

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