mono_realloc_native_code (struct MonoCompile * cfg)
{
  void * D.26241;
  unsigned char * D.26242;
  unsigned int D.26243;

  D.26242 = cfg->native_code;
  D.26243 = cfg->code_size;
  D.26241 = monoeg_realloc (D.26242, D.26243);
  return D.26241;
}


mono_running_on_valgrind ()
{
  volatile unsigned int D.24146;
  gboolean D.26247;

  {
    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__("move $11, %1
	move $12, %2
	srl $0, $0, 13
	srl $0, $0, 29
	srl $0, $0, 3
	srl $0, $0, 19
	or $13, $13, $13
	move %0, $11
	" : "=r" _zzq_result : "r" 0, "r" &_zzq_args[0] : "t4", "t3", "memory", "cc");
    D.24146 = _zzq_result;
  }
  if (D.24146 != 0) goto <D.26245>; else goto <D.26246>;
  <D.26245>:
  D.26247 = 1;
  return D.26247;
  <D.26246>:
  D.26247 = 0;
  return D.26247;
}


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

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


get_method_from_ip (void * ip)
{
  union mono_mutex_t * D.26255;
  _Bool D.26258;
  long int D.26259;
  long int D.26260;
  void * D.26263;
  struct GHashTable * D.26264;
  _Bool D.26267;
  long int D.26268;
  long int D.26269;
  struct MonoMethod * D.26272;
  char * D.26275;
  struct MonoMethod * D.26276;
  struct MonoMethod * D.26277;
  int ip.0;
  void * D.26279;
  int D.26280;
  int D.26281;
  unsigned int D.26282;
  int D.26283;
  sizetype D.26284;
  char * D.26285;
  char * D.26286;
  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.26251>; else goto <D.26252>;
      <D.26251>:
      domain = mono_get_root_domain ();
      <D.26252>:
      ji = mono_jit_info_table_find (domain, ip);
      if (ji == 0B) goto <D.26253>; else goto <D.26254>;
      <D.26253>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

        D.26255 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.26255);
        if (ret != 0) goto <D.26256>; else goto <D.26257>;
        <D.26256>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26257>:
        D.26258 = ret != 0;
        D.26259 = (long int) D.26258;
        D.26260 = __builtin_expect (D.26259, 0);
        if (D.26260 != 0) goto <D.26261>; else goto <D.26262>;
        <D.26261>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 305, "ret == 0");
        <D.26262>:
      }
      D.26263 = domain->runtime_info;
      D.26264 = MEM[(struct MonoJitDomainInfo *)D.26263].jit_trampoline_hash;
      monoeg_g_hash_table_foreach (D.26264, find_tramp, &user_data);
      {
        int ret;

        D.26255 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.26255);
        if (ret != 0) goto <D.26265>; else goto <D.26266>;
        <D.26265>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26266>:
        D.26267 = ret != 0;
        D.26268 = (long int) D.26267;
        D.26269 = __builtin_expect (D.26268, 0);
        if (D.26269 != 0) goto <D.26270>; else goto <D.26271>;
        <D.26270>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 307, "ret == 0");
        <D.26271>:
      }
      D.26272 = user_data.method;
      if (D.26272 != 0B) goto <D.26273>; else goto <D.26274>;
      <D.26273>:
      {
        char * mname;

        D.26272 = user_data.method;
        mname = mono_method_full_name (D.26272, 1);
        res = monoeg_g_strdup_printf ("<%p - JIT trampoline for %s>", ip, mname);
        monoeg_g_free (mname);
        D.26275 = res;
        return D.26275;
      }
      <D.26274>:
      D.26275 = 0B;
      return D.26275;
      <D.26254>:
      D.26276 = jinfo_get_method (ji);
      method = mono_method_full_name (D.26276, 1);
      D.26277 = jinfo_get_method (ji);
      ip.0 = (int) ip;
      D.26279 = ji->code_start;
      D.26280 = (int) D.26279;
      D.26281 = ip.0 - D.26280;
      D.26282 = (unsigned int) D.26281;
      location = mono_debug_lookup_source_location (D.26277, D.26282, domain);
      ip.0 = (int) ip;
      D.26279 = ji->code_start;
      D.26280 = (int) D.26279;
      D.26281 = ip.0 - D.26280;
      D.26279 = ji->code_start;
      D.26279 = ji->code_start;
      D.26283 = ji->code_size;
      D.26284 = (sizetype) D.26283;
      D.26285 = D.26279 + D.26284;
      D.26286 = domain->friendly_name;
      res = monoeg_g_strdup_printf (" %s + 0x%x (%p %p) [%p - %s]", method, D.26281, D.26279, D.26285, domain, D.26286);
      mono_debug_free_source_location (location);
      monoeg_g_free (method);
      D.26275 = res;
      return D.26275;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


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

  ud = user_data;
  D.26289 = ud->ip;
  if (D.26289 == value) goto <D.26290>; else goto <D.26291>;
  <D.26290>:
  ud->method = key;
  <D.26291>:
}


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

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


mono_print_method_from_ip (void * ip)
{
  struct MonoDomain * target_domain.1;
  union mono_mutex_t * D.26297;
  _Bool D.26300;
  long int D.26301;
  long int D.26302;
  void * D.26305;
  struct GHashTable * D.26306;
  _Bool D.26309;
  long int D.26310;
  long int D.26311;
  struct MonoMethod * D.26314;
  guint8 * D.26317;
  unsigned int D.26320;
  guint8 * D.26321;
  int ip.2;
  int D.26325;
  int D.26326;
  char * D.26327;
  struct _IO_FILE * stdout.3;
  struct MonoMethod * D.26329;
  struct MonoMethod * D.26330;
  void * D.26331;
  int D.26332;
  int D.26333;
  unsigned int D.26334;
  struct MonoDomain * target_domain.4;
  gboolean * D.26341;
  gboolean * D.26343;
  int D.26344;
  sizetype D.26345;
  char * D.26346;
  char * D.26347;
  char * D.26350;
  unsigned int D.26351;
  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.26295>; else goto <D.26296>;
      <D.26295>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

        D.26297 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.26297);
        if (ret != 0) goto <D.26298>; else goto <D.26299>;
        <D.26298>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26299>:
        D.26300 = ret != 0;
        D.26301 = (long int) D.26300;
        D.26302 = __builtin_expect (D.26301, 0);
        if (D.26302 != 0) goto <D.26303>; else goto <D.26304>;
        <D.26303>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 379, "ret == 0");
        <D.26304>:
      }
      D.26305 = domain->runtime_info;
      D.26306 = MEM[(struct MonoJitDomainInfo *)D.26305].jit_trampoline_hash;
      monoeg_g_hash_table_foreach (D.26306, find_tramp, &user_data);
      {
        int ret;

        D.26297 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.26297);
        if (ret != 0) goto <D.26307>; else goto <D.26308>;
        <D.26307>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26308>:
        D.26309 = ret != 0;
        D.26310 = (long int) D.26309;
        D.26311 = __builtin_expect (D.26310, 0);
        if (D.26311 != 0) goto <D.26312>; else goto <D.26313>;
        <D.26312>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 381, "ret == 0");
        <D.26313>:
      }
      D.26314 = user_data.method;
      if (D.26314 != 0B) goto <D.26315>; else goto <D.26316>;
      <D.26315>:
      {
        char * mname;

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

        tinfo = l->data;
        D.26317 = tinfo->code;
        if (D.26317 <= ip) goto <D.26318>; else goto <D.26319>;
        <D.26318>:
        D.26317 = tinfo->code;
        D.26320 = tinfo->code_size;
        D.26321 = D.26317 + D.26320;
        if (D.26321 >= ip) goto <D.26322>; else goto <D.26323>;
        <D.26322>:
        ip.2 = (int) ip;
        D.26317 = tinfo->code;
        D.26325 = (int) D.26317;
        D.26326 = ip.2 - D.26325;
        D.26327 = tinfo->name;
        printf ("IP %p is at offset 0x%x of trampoline \'%s\'.\n", ip, D.26326, D.26327);
        return;
        <D.26323>:
        <D.26319>:
      }
      l = l->next;
      <D.24194>:
      if (l != 0B) goto <D.24193>; else goto <D.24195>;
      <D.24195>:
      monoeg_g_print ("No method at %p\n", ip);
      stdout.3 = stdout;
      fflush (stdout.3);
      return;
      <D.26296>:
      D.26329 = jinfo_get_method (ji);
      method = mono_method_full_name (D.26329, 1);
      D.26330 = jinfo_get_method (ji);
      ip.2 = (int) ip;
      D.26331 = ji->code_start;
      D.26332 = (int) D.26331;
      D.26333 = ip.2 - D.26332;
      D.26334 = (unsigned int) D.26333;
      target_domain.4 = target_domain;
      source = mono_debug_lookup_source_location (D.26330, D.26334, target_domain.4);
      gsctx = mono_jit_info_get_generic_sharing_context (ji);
      shared_type = "";
      if (gsctx != 0B) goto <D.26336>; else goto <D.26337>;
      <D.26336>:
      D.26341 = gsctx->var_is_vt;
      if (D.26341 != 0B) goto <D.26338>; else goto <D.26342>;
      <D.26342>:
      D.26343 = gsctx->mvar_is_vt;
      if (D.26343 != 0B) goto <D.26338>; else goto <D.26339>;
      <D.26338>:
      shared_type = "gsharedvt ";
      goto <D.26340>;
      <D.26339>:
      shared_type = "gshared ";
      <D.26340>:
      <D.26337>:
      ip.2 = (int) ip;
      D.26331 = ji->code_start;
      D.26332 = (int) D.26331;
      D.26333 = ip.2 - D.26332;
      D.26331 = ji->code_start;
      D.26331 = ji->code_start;
      D.26344 = ji->code_size;
      D.26345 = (sizetype) D.26344;
      D.26346 = D.26331 + D.26345;
      target_domain.4 = target_domain;
      target_domain.4 = target_domain;
      D.26347 = target_domain.4->friendly_name;
      monoeg_g_print ("IP %p at offset 0x%x of %smethod %s (%p %p)[domain %p - %s]\n", ip, D.26333, shared_type, method, D.26331, D.26346, target_domain.4, D.26347);
      if (source != 0B) goto <D.26348>; else goto <D.26349>;
      <D.26348>:
      D.26350 = source->source_file;
      D.26351 = source->row;
      monoeg_g_print ("%s:%d\n", D.26350, D.26351);
      <D.26349>:
      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.26355;

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


mono_method_same_domain (struct MonoJitInfo * caller, struct MonoJitInfo * callee)
{
  gboolean D.26360;
  unsigned int D.26361;
  unsigned int D.26362;
  unsigned int D.26365;
  unsigned int D.26366;
  struct MonoClass * D.26369;
  struct MonoClass * D.26370;
  const char * D.26373;
  char * D.26374;
  struct MonoMethod * cmethod;

  if (caller == 0B) goto <D.26357>; else goto <D.26359>;
  <D.26359>:
  if (callee == 0B) goto <D.26357>; else goto <D.26358>;
  <D.26357>:
  D.26360 = 0;
  return D.26360;
  <D.26358>:
  D.26361 = BIT_FIELD_REF <*caller, 32, 160>;
  D.26362 = D.26361 & 32768;
  if (D.26362 != 0) goto <D.26363>; else goto <D.26364>;
  <D.26363>:
  D.26365 = BIT_FIELD_REF <*callee, 32, 160>;
  D.26366 = D.26365 & 32768;
  if (D.26366 == 0) goto <D.26367>; else goto <D.26368>;
  <D.26367>:
  D.26360 = 0;
  return D.26360;
  <D.26368>:
  <D.26364>:
  cmethod = jinfo_get_method (caller);
  D.26369 = cmethod->klass;
  D.26370 = mono_defaults.appdomain_class;
  if (D.26369 == D.26370) goto <D.26371>; else goto <D.26372>;
  <D.26371>:
  D.26373 = cmethod->name;
  D.26374 = strstr (D.26373, "InvokeInDomain");
  if (D.26374 != 0B) goto <D.26375>; else goto <D.26376>;
  <D.26375>:
  D.26360 = 0;
  return D.26360;
  <D.26376>:
  <D.26372>:
  D.26360 = 1;
  return D.26360;
}


mono_global_codeman_reserve (int size)
{
  int mono_aot_only.5;
  struct MonoCodeManager * global_codeman.6;
  struct MonoCodeManager * global_codeman.7;
  void * D.26385;
  _Bool D.26388;
  long int D.26389;
  long int D.26390;
  _Bool D.26395;
  long int D.26396;
  long int D.26397;
  void * ptr;

  mono_aot_only.5 = mono_aot_only;
  if (mono_aot_only.5 != 0) goto <D.26379>; else goto <D.26380>;
  <D.26379>:
  monoeg_g_log (0B, 4, "Attempting to allocate from the global code manager while running with --aot-only.\n");
  <D.24205>:
  goto <D.24205>;
  <D.26380>:
  global_codeman.6 = global_codeman;
  if (global_codeman.6 == 0B) goto <D.26382>; else goto <D.26383>;
  <D.26382>:
  global_codeman.7 = mono_code_manager_new ();
  global_codeman = global_codeman.7;
  global_codeman.6 = global_codeman;
  D.26385 = mono_code_manager_reserve (global_codeman.6, size);
  return D.26385;
  <D.26383>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.26386>; else goto <D.26387>;
    <D.26386>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.26387>:
    D.26388 = ret != 0;
    D.26389 = (long int) D.26388;
    D.26390 = __builtin_expect (D.26389, 0);
    if (D.26390 != 0) goto <D.26391>; else goto <D.26392>;
    <D.26391>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 471, "ret == 0");
    <D.26392>:
  }
  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.26393>; else goto <D.26394>;
    <D.26393>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26394>:
    D.26395 = ret != 0;
    D.26396 = (long int) D.26395;
    D.26397 = __builtin_expect (D.26396, 0);
    if (D.26397 != 0) goto <D.26398>; else goto <D.26399>;
    <D.26398>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 473, "ret == 0");
    <D.26399>:
  }
  D.26385 = ptr;
  return D.26385;
}


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

  D.26401 = data;
  return D.26401;
}


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.26403;
  short unsigned int D.26404;
  unsigned int when.8;
  struct MonoUnwindOp * D.26406;
  struct MonoUnwindOp * op;

  op = monoeg_malloc0 (12);
  D.26403 = (unsigned char) tag;
  op->op = D.26403;
  D.26404 = (short unsigned int) reg;
  op->reg = D.26404;
  op->val = val;
  when.8 = (unsigned int) when;
  op->when = when.8;
  D.26406 = op;
  return D.26406;
}


mono_emit_unwind_op (struct MonoCompile * cfg, int when, int tag, int reg, int val)
{
  struct MonoMemPool * D.26408;
  unsigned char D.26409;
  short unsigned int D.26410;
  unsigned int when.9;
  struct GSList * D.26412;
  struct GSList * D.26413;
  unsigned int D.26414;
  const char * D.26417;
  const char * D.26418;
  const char * D.26419;
  int D.26420;
  struct MonoUnwindOp * op;

  D.26408 = cfg->mempool;
  op = mono_mempool_alloc0 (D.26408, 12);
  D.26409 = (unsigned char) tag;
  op->op = D.26409;
  D.26410 = (short unsigned int) reg;
  op->reg = D.26410;
  op->val = val;
  when.9 = (unsigned int) when;
  op->when = when.9;
  D.26408 = cfg->mempool;
  D.26412 = cfg->unwind_ops;
  D.26413 = g_slist_append_mempool (D.26408, D.26412, op);
  cfg->unwind_ops = D.26413;
  D.26414 = cfg->verbose_level;
  if (D.26414 > 1) goto <D.26415>; else goto <D.26416>;
  <D.26415>:
  switch (tag) <default: <D.26421>, case 12: <D.24236>, case 13: <D.24238>, case 14: <D.24239>, case 128: <D.24240>>
  <D.24236>:
  D.26417 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa: %s+0x%x\n", when, D.26417, val);
  goto <D.24237>;
  <D.24238>:
  D.26418 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa_reg: %s\n", when, D.26418);
  goto <D.24237>;
  <D.24239>:
  printf ("CFA: [%x] def_cfa_offset: 0x%x\n", when, val);
  goto <D.24237>;
  <D.24240>:
  D.26419 = mono_arch_regname (reg);
  D.26420 = -val;
  printf ("CFA: [%x] offset: %s at cfa-0x%x\n", when, D.26419, D.26420);
  goto <D.24237>;
  <D.26421>:
  <D.24237>:
  <D.26416>:
}


g_slist_append_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.26424;
  struct GSList * D.26425;
  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.26422>; else goto <D.26423>;
  <D.26422>:
  last = list;
  goto <D.13660>;
  <D.13659>:
  last = last->next;
  <D.13660>:
  D.26424 = last->next;
  if (D.26424 != 0B) goto <D.13659>; else goto <D.13661>;
  <D.13661>:
  last->next = new_list;
  D.26425 = list;
  return D.26425;
  <D.26423>:
  D.26425 = new_list;
  return D.26425;
}


mono_jump_info_token_new2 (struct MonoMemPool * mp, struct MonoImage * image, guint32 token, struct MonoGenericContext * context)
{
  _Bool D.26427;
  int D.26428;
  struct MonoGenericContext * D.26431;
  struct MonoJumpInfoToken * D.26432;
  struct MonoJumpInfoToken * res;

  res = mono_mempool_alloc0 (mp, 20);
  res->image = image;
  res->token = token;
  D.26427 = context != 0B;
  D.26428 = (int) D.26427;
  res->has_context = D.26428;
  if (context != 0B) goto <D.26429>; else goto <D.26430>;
  <D.26429>:
  D.26431 = &res->context;
  memcpy (D.26431, context, 8);
  <D.26430>:
  D.26432 = res;
  return D.26432;
}


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

  D.26435 = __builtin_object_size (__dest, 0);
  D.26434 = __builtin___memcpy_chk (__dest, __src, __len, D.26435);
  return D.26434;
}


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

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


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

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


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

  if (str != 0B) goto <D.26442>; else goto <D.26443>;
  <D.26442>:
  D.26444 = __strdup (str);
  return D.26444;
  <D.26443>:
  D.26444 = 0B;
  return D.26444;
}


mono_tramp_info_free (struct MonoTrampInfo * info)
{
  char * D.26446;
  void * D.26447;
  struct GSList * D.26448;
  struct GSList * l;

  D.26446 = info->name;
  monoeg_g_free (D.26446);
  l = info->unwind_ops;
  goto <D.24266>;
  <D.24265>:
  D.26447 = l->data;
  monoeg_g_free (D.26447);
  l = l->next;
  <D.24266>:
  if (l != 0B) goto <D.24265>; else goto <D.24267>;
  <D.24267>:
  D.26448 = info->unwind_ops;
  monoeg_g_slist_free (D.26448);
  monoeg_g_free (info);
}


mono_tramp_info_register (struct MonoTrampInfo * info)
{
  guint8 * D.26451;
  unsigned int D.26452;
  char * D.26453;
  gchar * D.26454;
  _Bool D.26457;
  long int D.26458;
  long int D.26459;
  struct GSList * tramp_infos.10;
  struct GSList * tramp_infos.11;
  _Bool D.26466;
  long int D.26467;
  long int D.26468;
  int D.26471;
  int D.26474;
  struct MonoTrampInfo * copy;

  if (info == 0B) goto <D.26449>; else goto <D.26450>;
  <D.26449>:
  return;
  <D.26450>:
  copy = monoeg_malloc0 (28);
  D.26451 = info->code;
  copy->code = D.26451;
  D.26452 = info->code_size;
  copy->code_size = D.26452;
  D.26453 = info->name;
  D.26454 = monoeg_strdup (D.26453);
  copy->name = D.26454;
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.26455>; else goto <D.26456>;
    <D.26455>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.26456>:
    D.26457 = ret != 0;
    D.26458 = (long int) D.26457;
    D.26459 = __builtin_expect (D.26458, 0);
    if (D.26459 != 0) goto <D.26460>; else goto <D.26461>;
    <D.26460>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 673, "ret == 0");
    <D.26461>:
  }
  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.26464>; else goto <D.26465>;
    <D.26464>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26465>:
    D.26466 = ret != 0;
    D.26467 = (long int) D.26466;
    D.26468 = __builtin_expect (D.26467, 0);
    if (D.26468 != 0) goto <D.26469>; else goto <D.26470>;
    <D.26469>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 675, "ret == 0");
    <D.26470>:
  }
  mono_save_trampoline_xdebug_info (info);
  D.26471 = mono_jit_map_is_enabled ();
  if (D.26471 != 0) goto <D.26472>; else goto <D.26473>;
  <D.26472>:
  D.26451 = info->code;
  D.26452 = info->code_size;
  D.26474 = (int) D.26452;
  D.26453 = info->name;
  mono_emit_jit_tramp (D.26451, D.26474, D.26453);
  <D.26473>:
  mono_tramp_info_free (info);
}


mono_debug_count ()
{
  int count.12;
  int count.13;
  const gchar * D.26478;
  gboolean D.26481;
  const gchar * D.26482;
  int D.26483;
  const gchar * D.26486;
  int D.26487;
  static int count = 0;

  count.12 = count;
  count.13 = count.12 + 1;
  count = count.13;
  D.26478 = monoeg_g_getenv ("COUNT");
  if (D.26478 == 0B) goto <D.26479>; else goto <D.26480>;
  <D.26479>:
  D.26481 = 1;
  return D.26481;
  <D.26480>:
  D.26482 = monoeg_g_getenv ("COUNT");
  D.26483 = atoi (D.26482);
  count.12 = count;
  if (D.26483 == count.12) goto <D.26484>; else goto <D.26485>;
  <D.26484>:
  break_count ();
  <D.26485>:
  D.26486 = monoeg_g_getenv ("COUNT");
  D.26487 = atoi (D.26486);
  count.12 = count;
  if (D.26487 < count.12) goto <D.26488>; else goto <D.26489>;
  <D.26488>:
  D.26481 = 0;
  return D.26481;
  <D.26489>:
  D.26481 = 1;
  return D.26481;
}


break_count ()
{

}


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

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


mono_unlink_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * from, struct MonoBasicBlock * to)
{
  struct MonoBasicBlock * * D.26493;
  unsigned int i.14;
  unsigned int D.26495;
  struct MonoBasicBlock * * D.26496;
  struct MonoBasicBlock * D.26497;
  short int D.26500;
  int D.26501;
  int pos.15;
  unsigned int pos.16;
  unsigned int D.26508;
  struct MonoBasicBlock * * D.26509;
  int D.26510;
  _Bool D.26511;
  long int D.26512;
  long int D.26513;
  short int D.26516;
  unsigned short D.26517;
  unsigned short D.26518;
  short int D.26519;
  struct MonoBasicBlock * * D.26520;
  struct MonoBasicBlock * * D.26521;
  struct MonoBasicBlock * D.26522;
  short int D.26525;
  int D.26526;
  int pos.17;
  unsigned int pos.18;
  unsigned int D.26533;
  struct MonoBasicBlock * * D.26534;
  int D.26535;
  _Bool D.26536;
  long int D.26537;
  long int D.26538;
  short int D.26541;
  unsigned short D.26542;
  unsigned short D.26543;
  short int D.26544;
  int i;
  int pos;
  gboolean found;

  found = 0;
  i = 0;
  goto <D.24291>;
  <D.24290>:
  D.26493 = from->out_bb;
  i.14 = (unsigned int) i;
  D.26495 = i.14 * 4;
  D.26496 = D.26493 + D.26495;
  D.26497 = *D.26496;
  if (D.26497 == to) goto <D.26498>; else goto <D.26499>;
  <D.26498>:
  found = 1;
  goto <D.24289>;
  <D.26499>:
  i = i + 1;
  <D.24291>:
  D.26500 = from->out_count;
  D.26501 = (int) D.26500;
  if (D.26501 > i) goto <D.24290>; else goto <D.24289>;
  <D.24289>:
  if (found != 0) goto <D.26502>; else goto <D.26503>;
  <D.26502>:
  pos = 0;
  i = 0;
  goto <D.24293>;
  <D.24292>:
  D.26493 = from->out_bb;
  i.14 = (unsigned int) i;
  D.26495 = i.14 * 4;
  D.26496 = D.26493 + D.26495;
  D.26497 = *D.26496;
  if (D.26497 != to) goto <D.26504>; else goto <D.26505>;
  <D.26504>:
  D.26493 = from->out_bb;
  pos.15 = pos;
  pos = pos.15 + 1;
  pos.16 = (unsigned int) pos.15;
  D.26508 = pos.16 * 4;
  D.26509 = D.26493 + D.26508;
  D.26493 = from->out_bb;
  i.14 = (unsigned int) i;
  D.26495 = i.14 * 4;
  D.26496 = D.26493 + D.26495;
  D.26497 = *D.26496;
  *D.26509 = D.26497;
  <D.26505>:
  i = i + 1;
  <D.24293>:
  D.26500 = from->out_count;
  D.26501 = (int) D.26500;
  if (D.26501 > i) goto <D.24292>; else goto <D.24294>;
  <D.24294>:
  D.26500 = from->out_count;
  D.26501 = (int) D.26500;
  D.26510 = D.26501 + -1;
  D.26511 = D.26510 != pos;
  D.26512 = (long int) D.26511;
  D.26513 = __builtin_expect (D.26512, 0);
  if (D.26513 != 0) goto <D.26514>; else goto <D.26515>;
  <D.26514>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 744, "pos == from->out_count - 1");
  <D.26515>:
  D.26500 = from->out_count;
  D.26516 = D.26500;
  D.26517 = (unsigned short) D.26516;
  D.26518 = D.26517 + 65535;
  D.26519 = (short int) D.26518;
  from->out_count = D.26519;
  <D.26503>:
  found = 0;
  i = 0;
  goto <D.24297>;
  <D.24296>:
  D.26520 = to->in_bb;
  i.14 = (unsigned int) i;
  D.26495 = i.14 * 4;
  D.26521 = D.26520 + D.26495;
  D.26522 = *D.26521;
  if (D.26522 == from) goto <D.26523>; else goto <D.26524>;
  <D.26523>:
  found = 1;
  goto <D.24295>;
  <D.26524>:
  i = i + 1;
  <D.24297>:
  D.26525 = to->in_count;
  D.26526 = (int) D.26525;
  if (D.26526 > i) goto <D.24296>; else goto <D.24295>;
  <D.24295>:
  if (found != 0) goto <D.26527>; else goto <D.26528>;
  <D.26527>:
  pos = 0;
  i = 0;
  goto <D.24299>;
  <D.24298>:
  D.26520 = to->in_bb;
  i.14 = (unsigned int) i;
  D.26495 = i.14 * 4;
  D.26521 = D.26520 + D.26495;
  D.26522 = *D.26521;
  if (D.26522 != from) goto <D.26529>; else goto <D.26530>;
  <D.26529>:
  D.26520 = to->in_bb;
  pos.17 = pos;
  pos = pos.17 + 1;
  pos.18 = (unsigned int) pos.17;
  D.26533 = pos.18 * 4;
  D.26534 = D.26520 + D.26533;
  D.26520 = to->in_bb;
  i.14 = (unsigned int) i;
  D.26495 = i.14 * 4;
  D.26521 = D.26520 + D.26495;
  D.26522 = *D.26521;
  *D.26534 = D.26522;
  <D.26530>:
  i = i + 1;
  <D.24299>:
  D.26525 = to->in_count;
  D.26526 = (int) D.26525;
  if (D.26526 > i) goto <D.24298>; else goto <D.24300>;
  <D.24300>:
  D.26525 = to->in_count;
  D.26526 = (int) D.26525;
  D.26535 = D.26526 + -1;
  D.26536 = D.26535 != pos;
  D.26537 = (long int) D.26536;
  D.26538 = __builtin_expect (D.26537, 0);
  if (D.26538 != 0) goto <D.26539>; else goto <D.26540>;
  <D.26539>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 761, "pos == to->in_count - 1");
  <D.26540>:
  D.26525 = to->in_count;
  D.26541 = D.26525;
  D.26542 = (unsigned short) D.26541;
  D.26543 = D.26542 + 65535;
  D.26544 = (short int) D.26543;
  to->in_count = D.26544;
  <D.26528>:
}


mono_bblocks_linked (struct MonoBasicBlock * bb1, struct MonoBasicBlock * bb2)
{
  struct MonoBasicBlock * * D.26545;
  unsigned int i.19;
  unsigned int D.26547;
  struct MonoBasicBlock * * D.26548;
  struct MonoBasicBlock * D.26549;
  gboolean D.26552;
  short int D.26553;
  int D.26554;
  int i;

  i = 0;
  goto <D.24307>;
  <D.24306>:
  D.26545 = bb1->out_bb;
  i.19 = (unsigned int) i;
  D.26547 = i.19 * 4;
  D.26548 = D.26545 + D.26547;
  D.26549 = *D.26548;
  if (D.26549 == bb2) goto <D.26550>; else goto <D.26551>;
  <D.26550>:
  D.26552 = 1;
  return D.26552;
  <D.26551>:
  i = i + 1;
  <D.24307>:
  D.26553 = bb1->out_count;
  D.26554 = (int) D.26553;
  if (D.26554 > i) goto <D.24306>; else goto <D.24308>;
  <D.24308>:
  D.26552 = 0;
  return D.26552;
}


mono_get_block_region_notry (struct MonoCompile * cfg, int region)
{
  int D.26556;
  int D.26559;
  int iftmp.20;
  <unnamed-unsigned:15> D.26565;
  int D.26566;
  _Bool D.26567;
  long int D.26568;
  long int D.26569;
  struct MonoExceptionClause * D.26572;
  unsigned int clause_index.21;
  unsigned int D.26574;
  struct MonoExceptionClause * D.26575;
  unsigned int D.26576;
  int D.26577;
  int D.26578;

  D.26556 = region & 240;
  if (D.26556 == 0) goto <D.26557>; else goto <D.26558>;
  <D.26557>:
  {
    struct MonoMethodHeader * header;
    int clause_index;

    header = cfg->header;
    D.26559 = region >> 8;
    clause_index = D.26559 + -1;
    if (clause_index < 0) goto <D.26561>; else goto <D.26564>;
    <D.26564>:
    D.26565 = header->num_clauses;
    D.26566 = (int) D.26565;
    if (D.26566 <= clause_index) goto <D.26561>; else goto <D.26562>;
    <D.26561>:
    iftmp.20 = 1;
    goto <D.26563>;
    <D.26562>:
    iftmp.20 = 0;
    <D.26563>:
    D.26567 = iftmp.20 != 0;
    D.26568 = (long int) D.26567;
    D.26569 = __builtin_expect (D.26568, 0);
    if (D.26569 != 0) goto <D.26570>; else goto <D.26571>;
    <D.26570>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 826, "clause_index >= 0 && clause_index < header->num_clauses");
    <D.26571>:
    D.26572 = header->clauses;
    clause_index.21 = (unsigned int) clause_index;
    D.26574 = clause_index.21 * 24;
    D.26575 = D.26572 + D.26574;
    D.26576 = D.26575->try_offset;
    D.26577 = (int) D.26576;
    region = mono_find_block_region_notry (cfg, D.26577);
  }
  <D.26558>:
  D.26578 = region;
  return D.26578;
}


mono_find_block_region_notry (struct MonoCompile * cfg, int offset)
{
  struct MonoExceptionClause * D.26580;
  unsigned int i.22;
  unsigned int D.26582;
  unsigned int D.26583;
  unsigned int offset.23;
  unsigned int D.26587;
  unsigned int D.26590;
  int D.26593;
  int D.26594;
  int D.26595;
  unsigned int D.26596;
  unsigned int D.26597;
  unsigned int D.26598;
  unsigned int D.26601;
  unsigned int D.26602;
  unsigned int D.26607;
  unsigned int D.26610;
  unsigned int D.26611;
  <unnamed-unsigned:15> D.26612;
  int D.26613;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  int i;

  header = cfg->header;
  i = 0;
  goto <D.24317>;
  <D.24316>:
  D.26580 = header->clauses;
  i.22 = (unsigned int) i;
  D.26582 = i.22 * 24;
  clause = D.26580 + D.26582;
  D.26583 = clause->flags;
  if (D.26583 == 1) goto <D.26584>; else goto <D.26585>;
  <D.26584>:
  offset.23 = (unsigned int) offset;
  D.26587 = clause->data.filter_offset;
  if (offset.23 >= D.26587) goto <D.26588>; else goto <D.26589>;
  <D.26588>:
  offset.23 = (unsigned int) offset;
  D.26590 = clause->handler_offset;
  if (offset.23 < D.26590) goto <D.26591>; else goto <D.26592>;
  <D.26591>:
  D.26594 = i + 1;
  D.26595 = D.26594 << 8;
  D.26596 = (unsigned int) D.26595;
  D.26583 = clause->flags;
  D.26597 = D.26596 | D.26583;
  D.26598 = D.26597 | 128;
  D.26593 = (int) D.26598;
  return D.26593;
  <D.26592>:
  <D.26589>:
  <D.26585>:
  D.26590 = clause->handler_offset;
  offset.23 = (unsigned int) offset;
  if (D.26590 <= offset.23) goto <D.26599>; else goto <D.26600>;
  <D.26599>:
  offset.23 = (unsigned int) offset;
  D.26590 = clause->handler_offset;
  D.26601 = clause->handler_len;
  D.26602 = D.26590 + D.26601;
  if (offset.23 < D.26602) goto <D.26603>; else goto <D.26604>;
  <D.26603>:
  D.26583 = clause->flags;
  if (D.26583 == 2) goto <D.26605>; else goto <D.26606>;
  <D.26605>:
  D.26594 = i + 1;
  D.26595 = D.26594 << 8;
  D.26596 = (unsigned int) D.26595;
  D.26583 = clause->flags;
  D.26597 = D.26596 | D.26583;
  D.26607 = D.26597 | 16;
  D.26593 = (int) D.26607;
  return D.26593;
  <D.26606>:
  D.26583 = clause->flags;
  if (D.26583 == 4) goto <D.26608>; else goto <D.26609>;
  <D.26608>:
  D.26594 = i + 1;
  D.26595 = D.26594 << 8;
  D.26596 = (unsigned int) D.26595;
  D.26583 = clause->flags;
  D.26597 = D.26596 | D.26583;
  D.26610 = D.26597 | 64;
  D.26593 = (int) D.26610;
  return D.26593;
  <D.26609>:
  D.26594 = i + 1;
  D.26595 = D.26594 << 8;
  D.26596 = (unsigned int) D.26595;
  D.26583 = clause->flags;
  D.26597 = D.26596 | D.26583;
  D.26611 = D.26597 | 32;
  D.26593 = (int) D.26611;
  return D.26593;
  <D.26604>:
  <D.26600>:
  i = i + 1;
  <D.24317>:
  D.26612 = header->num_clauses;
  D.26613 = (int) D.26612;
  if (D.26613 > i) goto <D.24316>; else goto <D.24318>;
  <D.24318>:
  D.26593 = -1;
  return D.26593;
}


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

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


mono_reverse_branch_op (guint32 opcode)
{
  unsigned int D.26619;
  int D.26622;
  unsigned int D.26624;
  int D.26627;
  unsigned int D.26629;
  int D.26632;
  unsigned int D.26634;
  int D.26637;
  guint32 D.26639;
  static const int reverse_map[10] = {64, 63, 62, 61, 60, 59, 68, 67, 66, 65};
  static const int reverse_fmap[10] = {663, 662, 661, 660, 659, 658, 667, 666, 665, 664};
  static const int reverse_lmap[10] = {556, 555, 554, 553, 552, 551, 560, 559, 558, 557};
  static const int reverse_imap[10] = {653, 652, 651, 650, 649, 648, 657, 656, 655, 654};

  D.26619 = opcode + 4294967237;
  if (D.26619 <= 9) goto <D.26620>; else goto <D.26621>;
  <D.26620>:
  D.26619 = opcode + 4294967237;
  D.26622 = reverse_map[D.26619];
  opcode = (guint32) D.26622;
  goto <D.26623>;
  <D.26621>:
  D.26624 = opcode + 4294966638;
  if (D.26624 <= 9) goto <D.26625>; else goto <D.26626>;
  <D.26625>:
  D.26624 = opcode + 4294966638;
  D.26627 = reverse_fmap[D.26624];
  opcode = (guint32) D.26627;
  goto <D.26628>;
  <D.26626>:
  D.26629 = opcode + 4294966745;
  if (D.26629 <= 9) goto <D.26630>; else goto <D.26631>;
  <D.26630>:
  D.26629 = opcode + 4294966745;
  D.26632 = reverse_lmap[D.26629];
  opcode = (guint32) D.26632;
  goto <D.26633>;
  <D.26631>:
  D.26634 = opcode + 4294966648;
  if (D.26634 <= 9) goto <D.26635>; else goto <D.26636>;
  <D.26635>:
  D.26634 = opcode + 4294966648;
  D.26637 = reverse_imap[D.26634];
  opcode = (guint32) D.26637;
  goto <D.26638>;
  <D.26636>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 889);
  <D.26638>:
  <D.26633>:
  <D.26628>:
  <D.26623>:
  D.26639 = opcode;
  return D.26639;
}


mono_type_to_store_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  unsigned int D.26641;
  unsigned int D.26642;
  guint D.26645;
  unsigned char D.26646;
  int D.26647;
  struct MonoClass * D.26648;
  unsigned int D.26649;
  unsigned int D.26650;
  struct MonoGenericClass * D.26655;
  struct MonoClass * D.26656;
  int D.26657;
  void handle_enum = <<< error >>>;

  D.26641 = BIT_FIELD_REF <*type, 32, 32>;
  D.26642 = D.26641 & 1073741824;
  if (D.26642 != 0) goto <D.26643>; else goto <D.26644>;
  <D.26643>:
  D.26645 = 374;
  return D.26645;
  <D.26644>:
  type = mini_replace_type (type);
  handle_enum:
  D.26646 = type->type;
  D.26647 = (int) D.26646;
  switch (D.26647) <default: <D.24377>, case 2: <D.24353>, case 3: <D.24356>, case 4: <D.24351>, case 5: <D.24352>, case 6: <D.24354>, case 7: <D.24355>, case 8: <D.24357>, case 9: <D.24358>, case 10: <D.24368>, case 11: <D.24369>, case 12: <D.24370>, case 13: <D.24371>, case 14: <D.24364>, case 15: <D.24361>, case 17: <D.24372>, case 18: <D.24363>, case 19: <D.24375>, case 20: <D.24367>, case 21: <D.24374>, case 22: <D.24373>, case 24: <D.24359>, case 25: <D.24360>, case 27: <D.24362>, case 28: <D.24365>, case 29: <D.24366>, case 30: <D.24376>>
  <D.24351>:
  <D.24352>:
  <D.24353>:
  D.26645 = 375;
  return D.26645;
  <D.24354>:
  <D.24355>:
  <D.24356>:
  D.26645 = 376;
  return D.26645;
  <D.24357>:
  <D.24358>:
  D.26645 = 377;
  return D.26645;
  <D.24359>:
  <D.24360>:
  <D.24361>:
  <D.24362>:
  D.26645 = 374;
  return D.26645;
  <D.24363>:
  <D.24364>:
  <D.24365>:
  <D.24366>:
  <D.24367>:
  D.26645 = 374;
  return D.26645;
  <D.24368>:
  <D.24369>:
  D.26645 = 378;
  return D.26645;
  <D.24370>:
  D.26645 = 379;
  return D.26645;
  <D.24371>:
  D.26645 = 380;
  return D.26645;
  <D.24372>:
  D.26648 = type->data.klass;
  D.26649 = BIT_FIELD_REF <*D.26648, 32, 160>;
  D.26650 = D.26649 & 16;
  if (D.26650 != 0) goto <D.26651>; else goto <D.26652>;
  <D.26651>:
  D.26648 = type->data.klass;
  type = mono_class_enum_basetype (D.26648);
  goto handle_enum;
  <D.26652>:
  if (0 != 0) goto <D.26653>; else goto <D.26654>;
  <D.26653>:
  D.26645 = 386;
  return D.26645;
  <D.26654>:
  D.26645 = 387;
  return D.26645;
  <D.24373>:
  D.26645 = 387;
  return D.26645;
  <D.24374>:
  D.26655 = type->data.generic_class;
  D.26656 = D.26655->container_class;
  type = &D.26656->byval_arg;
  goto handle_enum;
  <D.24375>:
  <D.24376>:
  D.26657 = mini_type_var_is_vt (cfg, type);
  if (D.26657 != 0) goto <D.26658>; else goto <D.26659>;
  <D.26658>:
  D.26645 = 387;
  return D.26645;
  <D.26659>:
  D.26645 = 374;
  return D.26645;
  <D.24377>:
  D.26646 = type->type;
  D.26647 = (int) D.26646;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_store_membase", D.26647);
  <D.24378>:
  goto <D.24378>;
  D.26645 = 4294967295;
  return D.26645;
}


mono_type_to_load_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  unsigned int D.26661;
  unsigned int D.26662;
  guint D.26665;
  unsigned char D.26666;
  int D.26667;
  int D.26670;
  struct MonoGenericSharingContext * D.26673;
  _Bool D.26674;
  long int D.26675;
  long int D.26676;
  int D.26679;

  D.26661 = BIT_FIELD_REF <*type, 32, 32>;
  D.26662 = D.26661 & 1073741824;
  if (D.26662 != 0) goto <D.26663>; else goto <D.26664>;
  <D.26663>:
  D.26665 = 388;
  return D.26665;
  <D.26664>:
  type = mini_replace_type (type);
  D.26666 = type->type;
  D.26667 = (int) D.26666;
  switch (D.26667) <default: <D.24409>, case 2: <D.24385>, case 3: <D.24388>, case 4: <D.24383>, case 5: <D.24384>, case 6: <D.24386>, case 7: <D.24387>, case 8: <D.24389>, case 9: <D.24390>, case 10: <D.24400>, case 11: <D.24401>, case 12: <D.24402>, case 13: <D.24403>, case 14: <D.24396>, case 15: <D.24393>, case 17: <D.24404>, case 18: <D.24395>, case 19: <D.24407>, case 20: <D.24399>, case 21: <D.24406>, case 22: <D.24405>, case 24: <D.24391>, case 25: <D.24392>, case 27: <D.24394>, case 28: <D.24397>, case 29: <D.24398>, case 30: <D.24408>>
  <D.24383>:
  D.26665 = 389;
  return D.26665;
  <D.24384>:
  <D.24385>:
  D.26665 = 390;
  return D.26665;
  <D.24386>:
  D.26665 = 391;
  return D.26665;
  <D.24387>:
  <D.24388>:
  D.26665 = 392;
  return D.26665;
  <D.24389>:
  D.26665 = 393;
  return D.26665;
  <D.24390>:
  D.26665 = 394;
  return D.26665;
  <D.24391>:
  <D.24392>:
  <D.24393>:
  <D.24394>:
  D.26665 = 388;
  return D.26665;
  <D.24395>:
  <D.24396>:
  <D.24397>:
  <D.24398>:
  <D.24399>:
  D.26665 = 388;
  return D.26665;
  <D.24400>:
  <D.24401>:
  D.26665 = 395;
  return D.26665;
  <D.24402>:
  D.26665 = 396;
  return D.26665;
  <D.24403>:
  D.26665 = 397;
  return D.26665;
  <D.24404>:
  if (0 != 0) goto <D.26668>; else goto <D.26669>;
  <D.26668>:
  D.26665 = 398;
  return D.26665;
  <D.26669>:
  <D.24405>:
  D.26665 = 399;
  return D.26665;
  <D.24406>:
  D.26670 = mono_type_generic_inst_is_valuetype (type);
  if (D.26670 != 0) goto <D.26671>; else goto <D.26672>;
  <D.26671>:
  D.26665 = 399;
  return D.26665;
  <D.26672>:
  D.26665 = 388;
  return D.26665;
  <D.24407>:
  <D.24408>:
  D.26673 = cfg->generic_sharing_context;
  D.26674 = D.26673 == 0B;
  D.26675 = (long int) D.26674;
  D.26676 = __builtin_expect (D.26675, 0);
  if (D.26676 != 0) goto <D.26677>; else goto <D.26678>;
  <D.26677>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1012, "cfg->generic_sharing_context");
  <D.26678>:
  D.26679 = mini_type_var_is_vt (cfg, type);
  if (D.26679 != 0) goto <D.26680>; else goto <D.26681>;
  <D.26680>:
  D.26665 = 399;
  return D.26665;
  <D.26681>:
  D.26665 = 388;
  return D.26665;
  <D.24409>:
  D.26666 = type->type;
  D.26667 = (int) D.26666;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_load_membase", D.26667);
  <D.24410>:
  goto <D.24410>;
  D.26665 = 4294967295;
  return D.26665;
}


mini_type_to_stind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.26683;
  unsigned int D.26686;
  unsigned int D.26687;
  unsigned char D.26692;
  int D.26694;
  guint D.26697;

  type = mini_replace_type (type);
  D.26683 = cfg->generic_sharing_context;
  if (D.26683 != 0B) goto <D.26684>; else goto <D.26685>;
  <D.26684>:
  D.26686 = BIT_FIELD_REF <*type, 32, 32>;
  D.26687 = D.26686 & 1073741824;
  if (D.26687 == 0) goto <D.26688>; else goto <D.26689>;
  <D.26688>:
  D.26692 = type->type;
  if (D.26692 == 19) goto <D.26690>; else goto <D.26693>;
  <D.26693>:
  D.26692 = type->type;
  if (D.26692 == 30) goto <D.26690>; else goto <D.26691>;
  <D.26690>:
  D.26694 = mini_type_var_is_vt (cfg, type);
  if (D.26694 != 0) goto <D.26695>; else goto <D.26696>;
  <D.26695>:
  D.26697 = 129;
  return D.26697;
  <D.26696>:
  D.26697 = 81;
  return D.26697;
  <D.26691>:
  <D.26689>:
  <D.26685>:
  D.26697 = mono_type_to_stind (type);
  return D.26697;
}


mono_op_imm_to_op (int opcode)
{
  int D.26699;
  const char * D.26700;

  switch (opcode) <default: <D.24458>, case 323: <D.24455>, case 327: <D.24456>, case 339: <D.24457>, case 429: <D.24422>, case 432: <D.24447>, case 434: <D.24448>, case 436: <D.24428>, case 437: <D.24429>, case 438: <D.24430>, case 538: <D.24424>, case 539: <D.24426>, case 541: <D.24432>, case 542: <D.24434>, case 543: <D.24436>, case 544: <D.24438>, case 545: <D.24440>, case 546: <D.24442>, case 620: <D.24453>, case 622: <D.24454>, case 625: <D.24423>, case 626: <D.24425>, case 627: <D.24427>, case 628: <D.24443>, case 629: <D.24444>, case 630: <D.24446>, case 631: <D.24445>, case 632: <D.24431>, case 633: <D.24433>, case 634: <D.24435>, case 635: <D.24437>, case 636: <D.24439>, case 637: <D.24441>, case 752: <D.24450>, case 754: <D.24452>, case 756: <D.24449>, case 758: <D.24451>>
  <D.24422>:
  D.26699 = 565;
  return D.26699;
  <D.24423>:
  D.26699 = 565;
  return D.26699;
  <D.24424>:
  D.26699 = 479;
  return D.26699;
  <D.24425>:
  D.26699 = 566;
  return D.26699;
  <D.24426>:
  D.26699 = 480;
  return D.26699;
  <D.24427>:
  D.26699 = 567;
  return D.26699;
  <D.24428>:
  D.26699 = 572;
  return D.26699;
  <D.24429>:
  D.26699 = 573;
  return D.26699;
  <D.24430>:
  D.26699 = 574;
  return D.26699;
  <D.24431>:
  D.26699 = 572;
  return D.26699;
  <D.24432>:
  D.26699 = 486;
  return D.26699;
  <D.24433>:
  D.26699 = 573;
  return D.26699;
  <D.24434>:
  D.26699 = 487;
  return D.26699;
  <D.24435>:
  D.26699 = 574;
  return D.26699;
  <D.24436>:
  D.26699 = 488;
  return D.26699;
  <D.24437>:
  D.26699 = 575;
  return D.26699;
  <D.24438>:
  D.26699 = 489;
  return D.26699;
  <D.24439>:
  D.26699 = 576;
  return D.26699;
  <D.24440>:
  D.26699 = 490;
  return D.26699;
  <D.24441>:
  D.26699 = 577;
  return D.26699;
  <D.24442>:
  D.26699 = 491;
  return D.26699;
  <D.24443>:
  D.26699 = 568;
  return D.26699;
  <D.24444>:
  D.26699 = 569;
  return D.26699;
  <D.24445>:
  D.26699 = 571;
  return D.26699;
  <D.24446>:
  D.26699 = 570;
  return D.26699;
  <D.24447>:
  D.26699 = 568;
  return D.26699;
  <D.24448>:
  D.26699 = 570;
  return D.26699;
  <D.24449>:
  D.26699 = 755;
  return D.26699;
  <D.24450>:
  D.26699 = 751;
  return D.26699;
  <D.24451>:
  D.26699 = 757;
  return D.26699;
  <D.24452>:
  D.26699 = 753;
  return D.26699;
  <D.24453>:
  D.26699 = 619;
  return D.26699;
  <D.24454>:
  D.26699 = 621;
  return D.26699;
  <D.24455>:
  D.26699 = 322;
  return D.26699;
  <D.24456>:
  D.26699 = 326;
  return D.26699;
  <D.24457>:
  D.26699 = 338;
  return D.26699;
  <D.24458>:
  D.26700 = mono_inst_name (opcode);
  printf ("%s\n", D.26700);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 1157);
  D.26699 = -1;
  return D.26699;
}


mono_decompose_op_imm (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  struct MonoMemPool * D.26702;
  int D.26703;
  struct MonoInst * D.26704;
  int D.26705;
  int D.26706;
  const unsigned char * D.26707;
  int D.26708;
  unsigned int D.26709;
  int D.26710;
  short unsigned int D.26711;
  int D.26712;
  int D.26713;
  short unsigned int D.26714;
  int D.26717;
  unsigned int D.26719;
  unsigned int D.26720;
  unsigned int D.26721;
  struct MonoInst * temp;

  D.26702 = cfg->mempool;
  temp = mono_mempool_alloc (D.26702, 56);
  temp->data.op[1].const_val = 0;
  D.26703 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.26703;
  temp->prev = 0B;
  D.26704 = temp->prev;
  temp->next = D.26704;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.26705 = temp->sreg3;
  temp->sreg2 = D.26705;
  D.26706 = temp->sreg2;
  temp->sreg1 = D.26706;
  D.26707 = cfg->ip;
  temp->cil_code = D.26707;
  D.26708 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.26708;
  D.26709 = mono_alloc_ireg (cfg);
  D.26710 = (int) D.26709;
  temp->dreg = D.26710;
  mono_bblock_insert_before_ins (bb, ins, temp);
  D.26711 = ins->opcode;
  D.26712 = (int) D.26711;
  D.26713 = mono_op_imm_to_op (D.26712);
  D.26714 = (short unsigned int) D.26713;
  ins->opcode = D.26714;
  D.26711 = ins->opcode;
  if (D.26711 == 338) goto <D.26715>; else goto <D.26716>;
  <D.26715>:
  D.26717 = temp->dreg;
  ins->sreg1 = D.26717;
  goto <D.26718>;
  <D.26716>:
  D.26717 = temp->dreg;
  ins->sreg2 = D.26717;
  <D.26718>:
  D.26719 = cfg->next_vreg;
  D.26720 = bb->max_vreg;
  D.26721 = MAX_EXPR <D.26719, D.26720>;
  bb->max_vreg = D.26721;
}


mono_compile_create_var_for_vreg (struct MonoCompile * cfg, struct MonoType * type, int opcode, int vreg)
{
  unsigned int D.26722;
  int D.26723;
  unsigned int D.26724;
  unsigned int D.26725;
  guint iftmp.25;
  struct MonoInst * * D.26732;
  unsigned int D.26733;
  void * D.26734;
  struct MonoMethodVar * D.26735;
  unsigned int D.26736;
  void * D.26737;
  unsigned int orig_count.26;
  unsigned int D.26739;
  void * D.26740;
  unsigned int orig_count.27;
  unsigned int D.26742;
  unsigned int D.26743;
  int D.26744;
  int D.26745;
  struct MonoMemPool * D.26746;
  int D.26747;
  struct MonoInst * D.26748;
  short unsigned int D.26749;
  int D.26750;
  int D.26751;
  const unsigned char * D.26752;
  struct MonoClass * D.26753;
  struct MonoClass * D.26754;
  unsigned char D.26755;
  unsigned int D.26758;
  unsigned int D.26759;
  unsigned int D.26762;
  unsigned int D.26763;
  int D.26770;
  unsigned int D.26772;
  unsigned int D.26773;
  int D.26774;
  unsigned char D.26775;
  unsigned char D.26776;
  unsigned int num.28;
  unsigned int D.26778;
  struct MonoInst * * D.26779;
  unsigned int D.26780;
  struct MonoMethodVar * D.26781;
  unsigned int num.29;
  int D.26785;
  int iftmp.30;
  struct MonoType * D.26794;
  unsigned char D.26795;
  struct MonoType * D.26797;
  unsigned char D.26798;
  unsigned char D.26800;
  unsigned char D.26801;
  int iftmp.31;
  struct MonoType * D.26808;
  unsigned char D.26809;
  struct MonoType * D.26811;
  unsigned char D.26812;
  unsigned int D.26815;
  int D.26818;
  int D.26819;
  int D.26820;
  int D.26821;
  unsigned int D.26824;
  unsigned int D.26825;
  int D.26832;
  struct MonoInst * D.26833;
  int D.26834;
  int D.26835;
  struct MonoClass * D.26838;
  struct MonoType * D.26839;
  struct MonoType * D.26840;
  struct MonoClass * D.26841;
  struct MonoClass * D.26844;
  unsigned int D.26845;
  char * D.26848;
  struct MonoInst * D.26849;
  struct MonoInst * inst;
  int num;
  gboolean regpair;

  D.26722 = cfg->num_varinfo;
  num = (int) D.26722;
  type = mini_replace_type (type);
  D.26723 = num + 1;
  D.26724 = (unsigned int) D.26723;
  D.26725 = cfg->varinfo_count;
  if (D.26724 >= D.26725) goto <D.26726>; else goto <D.26727>;
  <D.26726>:
  {
    int orig_count;

    D.26725 = cfg->varinfo_count;
    orig_count = (int) D.26725;
    D.26725 = cfg->varinfo_count;
    if (D.26725 != 0) goto <D.26729>; else goto <D.26730>;
    <D.26729>:
    D.26725 = cfg->varinfo_count;
    iftmp.25 = D.26725 * 2;
    goto <D.26731>;
    <D.26730>:
    iftmp.25 = 64;
    <D.26731>:
    cfg->varinfo_count = iftmp.25;
    D.26732 = cfg->varinfo;
    D.26725 = cfg->varinfo_count;
    D.26733 = D.26725 * 4;
    D.26734 = monoeg_realloc (D.26732, D.26733);
    cfg->varinfo = D.26734;
    D.26735 = cfg->vars;
    D.26725 = cfg->varinfo_count;
    D.26736 = D.26725 * 56;
    D.26737 = monoeg_realloc (D.26735, D.26736);
    cfg->vars = D.26737;
    D.26735 = cfg->vars;
    orig_count.26 = (unsigned int) orig_count;
    D.26739 = orig_count.26 * 56;
    D.26740 = D.26735 + D.26739;
    D.26725 = cfg->varinfo_count;
    orig_count.27 = (unsigned int) orig_count;
    D.26742 = D.26725 - orig_count.27;
    D.26743 = D.26742 * 56;
    memset (D.26740, 0, D.26743);
  }
  <D.26727>:
  D.26744 = cfg->stat_allocate_var;
  D.26745 = D.26744 + 1;
  cfg->stat_allocate_var = D.26745;
  D.26746 = cfg->mempool;
  inst = mono_mempool_alloc (D.26746, 56);
  inst->data.op[1].const_val = 0;
  D.26747 = inst->data.op[1].const_val;
  inst->data.op[0].const_val = D.26747;
  inst->prev = 0B;
  D.26748 = inst->prev;
  inst->next = D.26748;
  D.26749 = (short unsigned int) opcode;
  inst->opcode = D.26749;
  inst->flags = 0;
  inst->type = 0;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.26750 = inst->sreg3;
  inst->sreg2 = D.26750;
  D.26751 = inst->sreg2;
  inst->sreg1 = D.26751;
  D.26752 = cfg->ip;
  inst->cil_code = D.26752;
  inst->data.op[0].const_val = num;
  inst->data.op[1].vtype = type;
  D.26753 = mono_class_from_mono_type (type);
  inst->klass = D.26753;
  type_to_eval_stack_type (cfg, type, inst);
  inst->backend.is_pinvoke = 0;
  inst->dreg = vreg;
  D.26754 = inst->klass;
  D.26755 = D.26754->exception_type;
  if (D.26755 != 0) goto <D.26756>; else goto <D.26757>;
  <D.26756>:
  mono_cfg_set_exception (cfg, 7);
  <D.26757>:
  D.26758 = BIT_FIELD_REF <*cfg, 32, 3424>;
  D.26759 = D.26758 & 128;
  if (D.26759 != 0) goto <D.26760>; else goto <D.26761>;
  <D.26760>:
  D.26762 = BIT_FIELD_REF <*type, 32, 32>;
  D.26763 = D.26762 & 1073741824;
  if (D.26763 != 0) goto <D.26764>; else goto <D.26765>;
  <D.26764>:
  mono_mark_vreg_as_mp (cfg, vreg);
  goto <D.26766>;
  <D.26765>:
  {
    struct MonoType * t;

    t = mini_replace_type (type);
    D.26770 = mono_type_is_struct (t);
    if (D.26770 != 0) goto <D.26771>; else goto <D.26767>;
    <D.26771>:
    D.26754 = inst->klass;
    D.26772 = BIT_FIELD_REF <*D.26754, 32, 160>;
    D.26773 = D.26772 & 134217728;
    if (D.26773 != 0) goto <D.26768>; else goto <D.26767>;
    <D.26767>:
    D.26774 = mini_type_is_reference (cfg, t);
    if (D.26774 != 0) goto <D.26768>; else goto <D.26769>;
    <D.26768>:
    D.26775 = inst->flags;
    D.26776 = D.26775 | 128;
    inst->flags = D.26776;
    mono_mark_vreg_as_ref (cfg, vreg);
    <D.26769>:
  }
  <D.26766>:
  <D.26761>:
  D.26732 = cfg->varinfo;
  num.28 = (unsigned int) num;
  D.26778 = num.28 * 4;
  D.26779 = D.26732 + D.26778;
  *D.26779 = inst;
  D.26735 = cfg->vars;
  num.28 = (unsigned int) num;
  D.26780 = num.28 * 56;
  D.26781 = D.26735 + D.26780;
  D.26781->range.first_use.pos.bid = 65535;
  D.26735 = cfg->vars;
  num.28 = (unsigned int) num;
  D.26780 = num.28 * 56;
  D.26781 = D.26735 + D.26780;
  D.26781->reg = -1;
  D.26735 = cfg->vars;
  num.28 = (unsigned int) num;
  D.26780 = num.28 * 56;
  D.26781 = D.26735 + D.26780;
  num.29 = (unsigned int) num;
  D.26781->idx = num.29;
  D.26735 = cfg->vars;
  num.28 = (unsigned int) num;
  D.26780 = num.28 * 56;
  D.26781 = D.26735 + D.26780;
  D.26781->vreg = vreg;
  if (vreg != -1) goto <D.26783>; else goto <D.26784>;
  <D.26783>:
  set_vreg_to_inst (cfg, vreg, inst);
  <D.26784>:
  D.26785 = mono_arch_is_soft_float ();
  if (D.26785 != 0) goto <D.26786>; else goto <D.26787>;
  <D.26786>:
  D.26762 = BIT_FIELD_REF <*type, 32, 32>;
  D.26763 = D.26762 & 1073741824;
  if (D.26763 == 0) goto <D.26793>; else goto <D.26789>;
  <D.26793>:
  D.26794 = mono_type_get_underlying_type (type);
  D.26795 = D.26794->type;
  if (D.26795 == 10) goto <D.26790>; else goto <D.26796>;
  <D.26796>:
  D.26797 = mono_type_get_underlying_type (type);
  D.26798 = D.26797->type;
  if (D.26798 == 11) goto <D.26790>; else goto <D.26789>;
  <D.26789>:
  D.26762 = BIT_FIELD_REF <*type, 32, 32>;
  D.26763 = D.26762 & 1073741824;
  if (D.26763 == 0) goto <D.26799>; else goto <D.26791>;
  <D.26799>:
  D.26800 = type->type;
  D.26801 = D.26800 + 244;
  if (D.26801 <= 1) goto <D.26790>; else goto <D.26791>;
  <D.26790>:
  iftmp.30 = 1;
  goto <D.26792>;
  <D.26791>:
  iftmp.30 = 0;
  <D.26792>:
  regpair = iftmp.30;
  goto <D.26802>;
  <D.26787>:
  D.26762 = BIT_FIELD_REF <*type, 32, 32>;
  D.26763 = D.26762 & 1073741824;
  if (D.26763 == 0) goto <D.26807>; else goto <D.26804>;
  <D.26807>:
  D.26808 = mono_type_get_underlying_type (type);
  D.26809 = D.26808->type;
  if (D.26809 == 10) goto <D.26805>; else goto <D.26810>;
  <D.26810>:
  D.26811 = mono_type_get_underlying_type (type);
  D.26812 = D.26811->type;
  if (D.26812 == 11) goto <D.26805>; else goto <D.26804>;
  <D.26805>:
  iftmp.31 = 1;
  goto <D.26806>;
  <D.26804>:
  iftmp.31 = 0;
  <D.26806>:
  regpair = iftmp.31;
  <D.26802>:
  if (regpair != 0) goto <D.26813>; else goto <D.26814>;
  <D.26813>:
  {
    struct MonoInst * tree;

    D.26815 = cfg->verbose_level;
    if (D.26815 > 3) goto <D.26816>; else goto <D.26817>;
    <D.26816>:
    D.26818 = inst->dreg;
    D.26818 = inst->dreg;
    D.26819 = D.26818 + 1;
    D.26818 = inst->dreg;
    D.26820 = D.26818 + 2;
    printf ("  Create LVAR R%d (R%d, R%d)\n", D.26818, D.26819, D.26820);
    <D.26817>:
    D.26821 = mono_arch_is_soft_float ();
    if (D.26821 != 0) goto <D.26822>; else goto <D.26823>;
    <D.26822>:
    D.26824 = cfg->opt;
    D.26825 = D.26824 & 2097152;
    if (D.26825 != 0) goto <D.26826>; else goto <D.26827>;
    <D.26826>:
    D.26762 = BIT_FIELD_REF <*type, 32, 32>;
    D.26763 = D.26762 & 1073741824;
    if (D.26763 == 0) goto <D.26828>; else goto <D.26829>;
    <D.26828>:
    D.26800 = type->type;
    D.26801 = D.26800 + 244;
    if (D.26801 <= 1) goto <D.26830>; else goto <D.26831>;
    <D.26830>:
    inst->flags = 4;
    <D.26831>:
    <D.26829>:
    <D.26827>:
    <D.26823>:
    D.26746 = cfg->mempool;
    tree = mono_mempool_alloc (D.26746, 56);
    tree->data.op[1].const_val = 0;
    D.26832 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.26832;
    tree->prev = 0B;
    D.26833 = tree->prev;
    tree->next = D.26833;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.26834 = tree->sreg3;
    tree->sreg2 = D.26834;
    D.26835 = tree->sreg2;
    tree->sreg1 = D.26835;
    D.26752 = cfg->ip;
    tree->cil_code = D.26752;
    D.26818 = inst->dreg;
    D.26819 = D.26818 + 1;
    tree->dreg = D.26819;
    D.26824 = cfg->opt;
    D.26825 = D.26824 & 2097152;
    if (D.26825 != 0) goto <D.26836>; else goto <D.26837>;
    <D.26836>:
    tree->flags = 4;
    <D.26837>:
    tree->data.op[0].const_val = num;
    tree->type = 1;
    D.26838 = mono_defaults.int32_class;
    D.26839 = &D.26838->byval_arg;
    tree->data.op[1].vtype = D.26839;
    D.26840 = tree->data.op[1].vtype;
    D.26841 = mono_class_from_mono_type (D.26840);
    tree->klass = D.26841;
    D.26818 = inst->dreg;
    D.26819 = D.26818 + 1;
    set_vreg_to_inst (cfg, D.26819, tree);
    D.26746 = cfg->mempool;
    tree = mono_mempool_alloc (D.26746, 56);
    tree->data.op[1].const_val = 0;
    D.26832 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.26832;
    tree->prev = 0B;
    D.26833 = tree->prev;
    tree->next = D.26833;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.26834 = tree->sreg3;
    tree->sreg2 = D.26834;
    D.26835 = tree->sreg2;
    tree->sreg1 = D.26835;
    D.26752 = cfg->ip;
    tree->cil_code = D.26752;
    D.26818 = inst->dreg;
    D.26820 = D.26818 + 2;
    tree->dreg = D.26820;
    D.26824 = cfg->opt;
    D.26825 = D.26824 & 2097152;
    if (D.26825 != 0) goto <D.26842>; else goto <D.26843>;
    <D.26842>:
    tree->flags = 4;
    <D.26843>:
    tree->data.op[0].const_val = num;
    tree->type = 1;
    D.26838 = mono_defaults.int32_class;
    D.26839 = &D.26838->byval_arg;
    tree->data.op[1].vtype = D.26839;
    D.26840 = tree->data.op[1].vtype;
    D.26844 = mono_class_from_mono_type (D.26840);
    tree->klass = D.26844;
    D.26818 = inst->dreg;
    D.26820 = D.26818 + 2;
    set_vreg_to_inst (cfg, D.26820, tree);
  }
  <D.26814>:
  D.26722 = cfg->num_varinfo;
  D.26845 = D.26722 + 1;
  cfg->num_varinfo = D.26845;
  D.26815 = cfg->verbose_level;
  if (D.26815 > 2) goto <D.26846>; else goto <D.26847>;
  <D.26846>:
  D.26848 = mono_type_get_name (type);
  monoeg_g_print ("created temp %d (R%d) of type %s\n", num, vreg, D.26848);
  <D.26847>:
  D.26849 = inst;
  return D.26849;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.26853;
  int D.26858;
  void * D.26860;
  unsigned int D.26861;

  D.26853 = __builtin_constant_p (__len);
  if (D.26853 != 0) goto <D.26854>; else goto <D.26855>;
  <D.26854>:
  if (__len == 0) goto <D.26856>; else goto <D.26857>;
  <D.26856>:
  D.26858 = __builtin_constant_p (__ch);
  if (D.26858 == 0) goto <D.26851>; else goto <D.26859>;
  <D.26859>:
  if (__ch != 0) goto <D.26851>; else goto <D.26852>;
  <D.26851>:
  __warn_memset_zero_len ();
  D.26860 = __dest;
  return D.26860;
  <D.26852>:
  <D.26857>:
  <D.26855>:
  D.26861 = __builtin_object_size (__dest, 0);
  D.26860 = __builtin___memset_chk (__dest, __ch, __len, D.26861);
  return D.26860;
}


mono_arch_is_soft_float ()
{
  gboolean D.26863;

  D.26863 = 0;
  return D.26863;
}


set_vreg_to_inst (struct MonoCompile * cfg, int vreg, struct MonoInst * inst)
{
  unsigned int vreg.32;
  unsigned int D.26866;
  guint32 iftmp.33;
  struct MonoMemPool * D.26873;
  unsigned int D.26874;
  void * D.26875;
  struct MonoInst * * D.26878;
  unsigned int size.34;
  unsigned int D.26880;
  unsigned int vreg.35;
  unsigned int D.26882;
  struct MonoInst * * D.26883;

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

    tmp = cfg->vreg_to_inst;
    D.26866 = cfg->vreg_to_inst_len;
    size = (int) D.26866;
    goto <D.24473>;
    <D.24472>:
    D.26866 = cfg->vreg_to_inst_len;
    if (D.26866 != 0) goto <D.26870>; else goto <D.26871>;
    <D.26870>:
    D.26866 = cfg->vreg_to_inst_len;
    iftmp.33 = D.26866 * 2;
    goto <D.26872>;
    <D.26871>:
    iftmp.33 = 32;
    <D.26872>:
    cfg->vreg_to_inst_len = iftmp.33;
    <D.24473>:
    vreg.32 = (unsigned int) vreg;
    D.26866 = cfg->vreg_to_inst_len;
    if (vreg.32 >= D.26866) goto <D.24472>; else goto <D.24474>;
    <D.24474>:
    D.26873 = cfg->mempool;
    D.26866 = cfg->vreg_to_inst_len;
    D.26874 = D.26866 * 4;
    D.26875 = mono_mempool_alloc0 (D.26873, D.26874);
    cfg->vreg_to_inst = D.26875;
    if (size != 0) goto <D.26876>; else goto <D.26877>;
    <D.26876>:
    D.26878 = cfg->vreg_to_inst;
    size.34 = (unsigned int) size;
    D.26880 = size.34 * 4;
    memcpy (D.26878, tmp, D.26880);
    <D.26877>:
  }
  <D.26868>:
  D.26878 = cfg->vreg_to_inst;
  vreg.35 = (unsigned int) vreg;
  D.26882 = vreg.35 * 4;
  D.26883 = D.26878 + D.26882;
  *D.26883 = inst;
}


mono_compile_create_var (struct MonoCompile * cfg, struct MonoType * type, int opcode)
{
  unsigned int D.26887;
  unsigned int D.26888;
  struct MonoType * D.26890;
  unsigned char D.26891;
  struct MonoType * D.26893;
  unsigned char D.26894;
  unsigned int D.26895;
  int D.26898;
  unsigned char D.26901;
  unsigned char D.26902;
  unsigned int D.26904;
  unsigned int D.26905;
  struct MonoInst * D.26906;
  int dreg;

  type = mini_replace_type (type);
  D.26887 = BIT_FIELD_REF <*type, 32, 32>;
  D.26888 = D.26887 & 1073741824;
  if (D.26888 == 0) goto <D.26889>; else goto <D.26884>;
  <D.26889>:
  D.26890 = mono_type_get_underlying_type (type);
  D.26891 = D.26890->type;
  if (D.26891 == 10) goto <D.26885>; else goto <D.26892>;
  <D.26892>:
  D.26893 = mono_type_get_underlying_type (type);
  D.26894 = D.26893->type;
  if (D.26894 == 11) goto <D.26885>; else goto <D.26884>;
  <D.26885>:
  D.26895 = mono_alloc_dreg (cfg, 2);
  dreg = (int) D.26895;
  goto <D.26886>;
  <D.26884>:
  D.26898 = mono_arch_is_soft_float ();
  if (D.26898 != 0) goto <D.26899>; else goto <D.26896>;
  <D.26899>:
  D.26887 = BIT_FIELD_REF <*type, 32, 32>;
  D.26888 = D.26887 & 1073741824;
  if (D.26888 == 0) goto <D.26900>; else goto <D.26896>;
  <D.26900>:
  D.26901 = type->type;
  D.26902 = D.26901 + 244;
  if (D.26902 <= 1) goto <D.26903>; else goto <D.26896>;
  <D.26903>:
  D.26904 = mono_alloc_dreg (cfg, 4);
  dreg = (int) D.26904;
  goto <D.26897>;
  <D.26896>:
  D.26905 = mono_alloc_preg (cfg);
  dreg = (int) D.26905;
  <D.26897>:
  <D.26886>:
  D.26906 = mono_compile_create_var_for_vreg (cfg, type, opcode, dreg);
  return D.26906;
}


mono_compile_make_var_load (struct MonoCompile * cfg, struct MonoInst * dest, gssize var_index)
{
  struct MonoInst * * D.26908;
  unsigned int var_index.36;
  unsigned int D.26910;
  struct MonoInst * * D.26911;
  struct MonoInst * D.26912;
  struct MonoInst * D.26913;
  struct MonoType * D.26914;
  unsigned int D.26915;
  short unsigned int D.26916;
  struct MonoClass * D.26917;

  memset (dest, 0, 56);
  D.26908 = cfg->varinfo;
  var_index.36 = (unsigned int) var_index;
  D.26910 = var_index.36 * 4;
  D.26911 = D.26908 + D.26910;
  D.26912 = *D.26911;
  dest->data.op[0].src = D.26912;
  D.26913 = dest->data.op[0].src;
  D.26914 = D.26913->data.op[1].vtype;
  D.26915 = mini_type_to_ldind (cfg, D.26914);
  D.26916 = (short unsigned int) D.26915;
  dest->opcode = D.26916;
  D.26913 = dest->data.op[0].src;
  D.26914 = D.26913->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.26914, dest);
  D.26913 = dest->data.op[0].src;
  D.26917 = D.26913->klass;
  dest->klass = D.26917;
}


mini_type_to_ldind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.26918;
  unsigned int D.26921;
  unsigned int D.26922;
  unsigned char D.26927;
  int D.26929;
  guint D.26932;

  D.26918 = cfg->generic_sharing_context;
  if (D.26918 != 0B) goto <D.26919>; else goto <D.26920>;
  <D.26919>:
  D.26921 = BIT_FIELD_REF <*type, 32, 32>;
  D.26922 = D.26921 & 1073741824;
  if (D.26922 == 0) goto <D.26923>; else goto <D.26924>;
  <D.26923>:
  D.26927 = type->type;
  if (D.26927 == 19) goto <D.26925>; else goto <D.26928>;
  <D.26928>:
  D.26927 = type->type;
  if (D.26927 == 30) goto <D.26925>; else goto <D.26926>;
  <D.26925>:
  D.26929 = mini_type_var_is_vt (cfg, type);
  if (D.26929 != 0) goto <D.26930>; else goto <D.26931>;
  <D.26930>:
  D.26932 = 113;
  return D.26932;
  <D.26931>:
  D.26932 = 80;
  return D.26932;
  <D.26926>:
  <D.26924>:
  <D.26920>:
  D.26932 = mono_type_to_ldind (type);
  return D.26932;
}


mono_mark_vreg_as_ref (struct MonoCompile * cfg, int vreg)
{
  unsigned int vreg.37;
  unsigned int D.26935;
  guint32 iftmp.38;
  struct MonoMemPool * D.26942;
  unsigned int D.26943;
  void * D.26944;
  gboolean * D.26947;
  unsigned int size.39;
  unsigned int D.26949;
  unsigned int vreg.40;
  unsigned int D.26951;
  gboolean * D.26952;

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

    tmp = cfg->vreg_is_ref;
    D.26935 = cfg->vreg_is_ref_len;
    size = (int) D.26935;
    goto <D.24505>;
    <D.24504>:
    D.26935 = cfg->vreg_is_ref_len;
    if (D.26935 != 0) goto <D.26939>; else goto <D.26940>;
    <D.26939>:
    D.26935 = cfg->vreg_is_ref_len;
    iftmp.38 = D.26935 * 2;
    goto <D.26941>;
    <D.26940>:
    iftmp.38 = 32;
    <D.26941>:
    cfg->vreg_is_ref_len = iftmp.38;
    <D.24505>:
    vreg.37 = (unsigned int) vreg;
    D.26935 = cfg->vreg_is_ref_len;
    if (vreg.37 >= D.26935) goto <D.24504>; else goto <D.24506>;
    <D.24506>:
    D.26942 = cfg->mempool;
    D.26935 = cfg->vreg_is_ref_len;
    D.26943 = D.26935 * 4;
    D.26944 = mono_mempool_alloc0 (D.26942, D.26943);
    cfg->vreg_is_ref = D.26944;
    if (size != 0) goto <D.26945>; else goto <D.26946>;
    <D.26945>:
    D.26947 = cfg->vreg_is_ref;
    size.39 = (unsigned int) size;
    D.26949 = size.39 * 4;
    memcpy (D.26947, tmp, D.26949);
    <D.26946>:
  }
  <D.26937>:
  D.26947 = cfg->vreg_is_ref;
  vreg.40 = (unsigned int) vreg;
  D.26951 = vreg.40 * 4;
  D.26952 = D.26947 + D.26951;
  *D.26952 = 1;
}


mono_mark_vreg_as_mp (struct MonoCompile * cfg, int vreg)
{
  unsigned int vreg.41;
  unsigned int D.26954;
  guint32 iftmp.42;
  struct MonoMemPool * D.26961;
  unsigned int D.26962;
  void * D.26963;
  gboolean * D.26966;
  unsigned int size.43;
  unsigned int D.26968;
  unsigned int vreg.44;
  unsigned int D.26970;
  gboolean * D.26971;

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

    tmp = cfg->vreg_is_mp;
    D.26954 = cfg->vreg_is_mp_len;
    size = (int) D.26954;
    goto <D.24514>;
    <D.24513>:
    D.26954 = cfg->vreg_is_mp_len;
    if (D.26954 != 0) goto <D.26958>; else goto <D.26959>;
    <D.26958>:
    D.26954 = cfg->vreg_is_mp_len;
    iftmp.42 = D.26954 * 2;
    goto <D.26960>;
    <D.26959>:
    iftmp.42 = 32;
    <D.26960>:
    cfg->vreg_is_mp_len = iftmp.42;
    <D.24514>:
    vreg.41 = (unsigned int) vreg;
    D.26954 = cfg->vreg_is_mp_len;
    if (vreg.41 >= D.26954) goto <D.24513>; else goto <D.24515>;
    <D.24515>:
    D.26961 = cfg->mempool;
    D.26954 = cfg->vreg_is_mp_len;
    D.26962 = D.26954 * 4;
    D.26963 = mono_mempool_alloc0 (D.26961, D.26962);
    cfg->vreg_is_mp = D.26963;
    if (size != 0) goto <D.26964>; else goto <D.26965>;
    <D.26964>:
    D.26966 = cfg->vreg_is_mp;
    size.43 = (unsigned int) size;
    D.26968 = size.43 * 4;
    memcpy (D.26966, tmp, D.26968);
    <D.26965>:
  }
  <D.26956>:
  D.26966 = cfg->vreg_is_mp;
  vreg.44 = (unsigned int) vreg;
  D.26970 = vreg.44 * 4;
  D.26971 = D.26966 + D.26970;
  *D.26971 = 1;
}


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

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


type_from_stack_type (struct MonoInst * ins)
{
  unsigned char D.26974;
  int D.26975;
  struct MonoType * D.26976;
  struct MonoClass * D.26977;
  struct MonoClass * D.26978;
  struct MonoClass * D.26979;
  struct MonoClass * D.26980;
  struct MonoClass * D.26981;
  struct MonoClass * D.26984;
  unsigned int D.26987;
  unsigned int D.26988;

  D.26974 = ins->type;
  D.26975 = (int) D.26974;
  switch (D.26975) <default: <D.24526>, case 1: <D.24519>, case 2: <D.24520>, case 3: <D.24521>, case 4: <D.24522>, case 5: <D.24523>, case 6: <D.24524>, case 7: <D.24525>>
  <D.24519>:
  D.26977 = mono_defaults.int32_class;
  D.26976 = &D.26977->byval_arg;
  return D.26976;
  <D.24520>:
  D.26978 = mono_defaults.int64_class;
  D.26976 = &D.26978->byval_arg;
  return D.26976;
  <D.24521>:
  D.26979 = mono_defaults.int_class;
  D.26976 = &D.26979->byval_arg;
  return D.26976;
  <D.24522>:
  D.26980 = mono_defaults.double_class;
  D.26976 = &D.26980->byval_arg;
  return D.26976;
  <D.24523>:
  D.26981 = ins->klass;
  if (D.26981 != 0B) goto <D.26982>; else goto <D.26983>;
  <D.26982>:
  D.26981 = ins->klass;
  D.26976 = &D.26981->this_arg;
  return D.26976;
  <D.26983>:
  D.26984 = mono_defaults.object_class;
  D.26976 = &D.26984->this_arg;
  return D.26976;
  <D.24524>:
  D.26981 = ins->klass;
  if (D.26981 != 0B) goto <D.26985>; else goto <D.26986>;
  <D.26985>:
  D.26981 = ins->klass;
  D.26987 = BIT_FIELD_REF <*D.26981, 32, 160>;
  D.26988 = D.26987 & 8;
  if (D.26988 == 0) goto <D.26989>; else goto <D.26990>;
  <D.26989>:
  D.26981 = ins->klass;
  D.26976 = &D.26981->byval_arg;
  return D.26976;
  <D.26990>:
  <D.26986>:
  D.26984 = mono_defaults.object_class;
  D.26976 = &D.26984->byval_arg;
  return D.26976;
  <D.24525>:
  D.26981 = ins->klass;
  D.26976 = &D.26981->byval_arg;
  return D.26976;
  <D.24526>:
  D.26974 = ins->type;
  D.26975 = (int) D.26974;
  monoeg_g_log (0B, 4, "stack type %d to montype not handled\n", D.26975);
  <D.24527>:
  goto <D.24527>;
  D.26976 = 0B;
  return D.26976;
}


mono_add_ins_to_end (struct MonoBasicBlock * bb, struct MonoInst * inst)
{
  struct MonoInst * D.26992;
  struct MonoInst * D.26995;
  short unsigned int D.26999;
  int D.27000;
  short unsigned int D.27004;
  short unsigned int D.27006;
  short unsigned int D.27008;
  struct MonoInst * D.27011;
  short unsigned int D.27014;
  unsigned int opcode.45;
  unsigned int D.27019;
  struct MonoInst * D.27026;
  short unsigned int D.27027;
  int opcode;

  D.26992 = bb->code;
  if (D.26992 == 0B) goto <D.26993>; else goto <D.26994>;
  <D.26993>:
  D.26995 = bb->last_ins;
  if (D.26995 != 0B) goto <D.26996>; else goto <D.26997>;
  <D.26996>:
  D.26995 = bb->last_ins;
  D.26995->next = inst;
  D.26995 = bb->last_ins;
  inst->prev = D.26995;
  bb->last_ins = inst;
  goto <D.26998>;
  <D.26997>:
  bb->last_ins = inst;
  D.26995 = bb->last_ins;
  bb->code = D.26995;
  <D.26998>:
  return;
  <D.26994>:
  D.26995 = bb->last_ins;
  D.26999 = D.26995->opcode;
  D.27000 = (int) D.26999;
  switch (D.27000) <default: <D.24550>, case 59: <D.24538>, case 60: <D.24539>, case 61: <D.24540>, case 62: <D.24541>, case 63: <D.24542>, case 64: <D.24543>, case 65: <D.24544>, case 66: <D.24545>, case 67: <D.24546>, case 68: <D.24547>, case 370: <D.24548>, case 442: <D.24536>, case 759: <D.24537>>
  <D.24536>:
  <D.24537>:
  <D.24538>:
  <D.24539>:
  <D.24540>:
  <D.24541>:
  <D.24542>:
  <D.24543>:
  <D.24544>:
  <D.24545>:
  <D.24546>:
  <D.24547>:
  <D.24548>:
  D.26995 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.26995, inst);
  goto <D.24549>;
  <D.24550>:
  D.26995 = bb->last_ins;
  D.26999 = D.26995->opcode;
  D.27004 = D.26999 + 64985;
  if (D.27004 <= 9) goto <D.27001>; else goto <D.27005>;
  <D.27005>:
  D.26995 = bb->last_ins;
  D.26999 = D.26995->opcode;
  D.27006 = D.26999 + 64878;
  if (D.27006 <= 9) goto <D.27001>; else goto <D.27007>;
  <D.27007>:
  D.26995 = bb->last_ins;
  D.26999 = D.26995->opcode;
  D.27008 = D.26999 + 64888;
  if (D.27008 <= 9) goto <D.27001>; else goto <D.27002>;
  <D.27001>:
  D.26992 = bb->code;
  D.26995 = bb->last_ins;
  if (D.26992 == D.26995) goto <D.27009>; else goto <D.27010>;
  <D.27009>:
  D.26995 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.26995, inst);
  return;
  <D.27010>:
  D.26992 = bb->code;
  D.27011 = D.26992->next;
  D.26995 = bb->last_ins;
  if (D.27011 == D.26995) goto <D.27012>; else goto <D.27013>;
  <D.27012>:
  D.26992 = bb->code;
  D.27014 = D.26992->opcode;
  opcode = (int) D.27014;
  opcode.45 = (unsigned int) opcode;
  D.27019 = opcode.45 + 4294966974;
  if (D.27019 <= 1) goto <D.27015>; else goto <D.27020>;
  <D.27020>:
  if (opcode == 326) goto <D.27015>; else goto <D.27021>;
  <D.27021>:
  if (opcode == 327) goto <D.27015>; else goto <D.27022>;
  <D.27022>:
  if (opcode == 324) goto <D.27015>; else goto <D.27023>;
  <D.27023>:
  if (opcode == 325) goto <D.27015>; else goto <D.27024>;
  <D.27024>:
  if (opcode == 328) goto <D.27015>; else goto <D.27016>;
  <D.27015>:
  D.26992 = bb->code;
  mono_bblock_insert_before_ins (bb, D.26992, inst);
  goto <D.27017>;
  <D.27016>:
  D.26995 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.26995, inst);
  <D.27017>:
  goto <D.27025>;
  <D.27013>:
  D.26995 = bb->last_ins;
  D.27026 = D.26995->prev;
  D.27027 = D.27026->opcode;
  opcode = (int) D.27027;
  opcode.45 = (unsigned int) opcode;
  D.27019 = opcode.45 + 4294966974;
  if (D.27019 <= 1) goto <D.27028>; else goto <D.27031>;
  <D.27031>:
  if (opcode == 326) goto <D.27028>; else goto <D.27032>;
  <D.27032>:
  if (opcode == 327) goto <D.27028>; else goto <D.27033>;
  <D.27033>:
  if (opcode == 324) goto <D.27028>; else goto <D.27034>;
  <D.27034>:
  if (opcode == 325) goto <D.27028>; else goto <D.27035>;
  <D.27035>:
  if (opcode == 328) goto <D.27028>; else goto <D.27029>;
  <D.27028>:
  D.26995 = bb->last_ins;
  D.27026 = D.26995->prev;
  mono_bblock_insert_before_ins (bb, D.27026, inst);
  goto <D.27030>;
  <D.27029>:
  D.26995 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.26995, inst);
  <D.27030>:
  <D.27025>:
  goto <D.27003>;
  <D.27002>:
  D.26995 = bb->last_ins;
  if (D.26995 != 0B) goto <D.27036>; else goto <D.27037>;
  <D.27036>:
  D.26995 = bb->last_ins;
  D.26995->next = inst;
  D.26995 = bb->last_ins;
  inst->prev = D.26995;
  bb->last_ins = inst;
  goto <D.27038>;
  <D.27037>:
  bb->last_ins = inst;
  D.26995 = bb->last_ins;
  bb->code = D.26995;
  <D.27038>:
  <D.27003>:
  goto <D.24549>;
  <D.24549>:
}


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

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


mono_get_array_new_va_icall (int rank)
{
  _Bool D.27044;
  long int D.27045;
  long int D.27046;
  struct GHashTable * jit_icall_name_hash.46;
  _Bool D.27054;
  long int D.27055;
  long int D.27056;
  struct MonoJitICallInfo * D.27059;
  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.27042>; else goto <D.27043>;
        <D.27042>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27043>:
        D.27044 = ret != 0;
        D.27045 = (long int) D.27044;
        D.27046 = __builtin_expect (D.27045, 0);
        if (D.27046 != 0) goto <D.27047>; else goto <D.27048>;
        <D.27047>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1561, "ret == 0");
        <D.27048>:
      }
      info = mono_find_jit_icall_by_name (&icall_name);
      if (info == 0B) goto <D.27049>; else goto <D.27050>;
      <D.27049>:
      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.27050>:
      {
        int ret;

        ret = pthread_mutex_unlock (&jit_mutex.mutex);
        if (ret != 0) goto <D.27052>; else goto <D.27053>;
        <D.27052>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27053>:
        D.27054 = ret != 0;
        D.27055 = (long int) D.27054;
        D.27056 = __builtin_expect (D.27055, 0);
        if (D.27056 != 0) goto <D.27057>; else goto <D.27058>;
        <D.27057>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1570, "ret == 0");
        <D.27058>:
      }
      D.27059 = info;
      return D.27059;
    }
  finally
    {
      icall_name = {CLOBBER};
    }
}


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

  D.27063 = __builtin_object_size (__s, 1);
  D.27062 = __builtin___sprintf_chk (__s, 1, D.27063, __fmt, __builtin_va_arg_pack ());
  return D.27062;
}


mono_get_array_new_va_signature (int arity)
{
  _Bool D.27067;
  long int D.27068;
  long int D.27069;
  struct GHashTable * sighash.47;
  struct GHashTable * sighash.48;
  const void * arity.49;
  _Bool D.27082;
  long int D.27083;
  long int D.27084;
  struct MonoMethodSignature * D.27087;
  struct MonoImage * D.27088;
  int D.27089;
  unsigned int D.27090;
  struct MonoClass * D.27093;
  struct MonoType * D.27094;
  int D.27095;
  struct MonoClass * D.27096;
  struct MonoType * D.27097;
  void * arity.50;
  _Bool D.27101;
  long int D.27102;
  long int D.27103;
  static struct GHashTable * sighash = 0B;
  struct MonoMethodSignature * res;
  int i;

  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27065>; else goto <D.27066>;
    <D.27065>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27066>:
    D.27067 = ret != 0;
    D.27068 = (long int) D.27067;
    D.27069 = __builtin_expect (D.27068, 0);
    if (D.27069 != 0) goto <D.27070>; else goto <D.27071>;
    <D.27070>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1518, "ret == 0");
    <D.27071>:
  }
  sighash.47 = sighash;
  if (sighash.47 == 0B) goto <D.27073>; else goto <D.27074>;
  <D.27073>:
  sighash.48 = monoeg_g_hash_table_new (0B, 0B);
  sighash = sighash.48;
  goto <D.27076>;
  <D.27074>:
  sighash.47 = sighash;
  arity.49 = (const void *) arity;
  res = monoeg_g_hash_table_lookup (sighash.47, arity.49);
  if (res != 0B) goto <D.27078>; else goto <D.27079>;
  <D.27078>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27080>; else goto <D.27081>;
    <D.27080>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27081>:
    D.27082 = ret != 0;
    D.27083 = (long int) D.27082;
    D.27084 = __builtin_expect (D.27083, 0);
    if (D.27084 != 0) goto <D.27085>; else goto <D.27086>;
    <D.27085>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1523, "ret == 0");
    <D.27086>:
  }
  D.27087 = res;
  return D.27087;
  <D.27079>:
  <D.27076>:
  D.27088 = mono_defaults.corlib;
  D.27089 = arity + 1;
  D.27090 = (unsigned int) D.27089;
  res = mono_metadata_signature_alloc (D.27088, D.27090);
  res->pinvoke = 1;
  if (0 != 0) goto <D.27091>; else goto <D.27092>;
  <D.27091>:
  res->call_convention = 5;
  <D.27092>:
  D.27093 = mono_defaults.int_class;
  D.27094 = &D.27093->byval_arg;
  res->params[0] = D.27094;
  i = 0;
  goto <D.24568>;
  <D.24567>:
  D.27095 = i + 1;
  D.27093 = mono_defaults.int_class;
  D.27094 = &D.27093->byval_arg;
  res->params[D.27095] = D.27094;
  i = i + 1;
  <D.24568>:
  if (i < arity) goto <D.24567>; else goto <D.24569>;
  <D.24569>:
  D.27096 = mono_defaults.object_class;
  D.27097 = &D.27096->byval_arg;
  res->ret = D.27097;
  sighash.47 = sighash;
  arity.50 = (void *) arity;
  monoeg_g_hash_table_insert_replace (sighash.47, arity.50, res, 0);
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27099>; else goto <D.27100>;
    <D.27099>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27100>:
    D.27101 = ret != 0;
    D.27102 = (long int) D.27101;
    D.27103 = __builtin_expect (D.27102, 0);
    if (D.27103 != 0) goto <D.27104>; else goto <D.27105>;
    <D.27104>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1545, "ret == 0");
    <D.27105>:
  }
  D.27087 = res;
  return D.27087;
}


mini_class_is_system_array (struct MonoClass * klass)
{
  struct MonoClass * D.27107;
  struct MonoClass * D.27108;
  gboolean D.27111;

  D.27107 = klass->parent;
  D.27108 = mono_defaults.array_class;
  if (D.27107 == D.27108) goto <D.27109>; else goto <D.27110>;
  <D.27109>:
  D.27111 = 1;
  return D.27111;
  <D.27110>:
  D.27111 = 0;
  return D.27111;
}


mini_assembly_can_skip_verification (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoClass * D.27113;
  struct MonoImage * D.27114;
  unsigned int D.27115;
  unsigned int D.27116;
  gboolean D.27121;
  unsigned char D.27124;
  struct MonoImage * D.27126;
  struct MonoImage * D.27127;
  int D.27128;
  struct MonoAssembly * assembly;

  D.27113 = method->klass;
  D.27114 = D.27113->image;
  assembly = D.27114->assembly;
  D.27115 = BIT_FIELD_REF <*method, 32, 160>;
  D.27116 = D.27115 & 124;
  if (D.27116 != 0) goto <D.27117>; else goto <D.27118>;
  <D.27117>:
  D.27115 = BIT_FIELD_REF <*method, 32, 160>;
  D.27116 = D.27115 & 124;
  if (D.27116 != 68) goto <D.27119>; else goto <D.27120>;
  <D.27119>:
  D.27121 = 0;
  return D.27121;
  <D.27120>:
  <D.27118>:
  D.27124 = assembly->in_gac;
  if (D.27124 != 0) goto <D.27122>; else goto <D.27125>;
  <D.27125>:
  D.27126 = assembly->image;
  D.27127 = mono_defaults.corlib;
  if (D.27126 == D.27127) goto <D.27122>; else goto <D.27123>;
  <D.27122>:
  D.27121 = 0;
  return D.27121;
  <D.27123>:
  D.27128 = mono_is_security_manager_active ();
  if (D.27128 != 0) goto <D.27129>; else goto <D.27130>;
  <D.27129>:
  D.27121 = 0;
  return D.27121;
  <D.27130>:
  D.27121 = mono_assembly_has_skip_verification (assembly);
  return D.27121;
}


mono_compile_is_broken (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  struct MonoClass * D.27132;
  struct MonoImage * D.27133;
  struct MonoAssembly * D.27134;
  unsigned char D.27135;
  unsigned int D.27136;
  unsigned int D.27137;
  gboolean D.27138;
  int iftmp.51;
  int D.27143;
  struct MonoMethod * method_definition;
  gboolean dont_verify;

  method_definition = method;
  D.27132 = method->klass;
  D.27133 = D.27132->image;
  D.27134 = D.27133->assembly;
  D.27135 = D.27134->corlib_internal;
  dont_verify = (gboolean) D.27135;
  goto <D.24612>;
  <D.24611>:
  {
    struct MonoMethodInflated * imethod;

    imethod = method_definition;
    method_definition = imethod->declaring;
  }
  <D.24612>:
  D.27136 = BIT_FIELD_REF <*method_definition, 32, 160>;
  D.27137 = D.27136 & 4096;
  if (D.27137 != 0) goto <D.24611>; else goto <D.24613>;
  <D.24613>:
  if (dont_verify == 0) goto <D.27142>; else goto <D.27140>;
  <D.27142>:
  D.27143 = mini_method_verify (cfg, method_definition, fail_compile);
  if (D.27143 != 0) goto <D.27144>; else goto <D.27140>;
  <D.27144>:
  iftmp.51 = 1;
  goto <D.27141>;
  <D.27140>:
  iftmp.51 = 0;
  <D.27141>:
  D.27138 = iftmp.51;
  return D.27138;
}


mini_method_verify (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  unsigned int D.27146;
  unsigned int D.27147;
  gboolean D.27150;
  int D.27151;
  int iftmp.52;
  int D.27158;
  struct MonoDomain * D.27160;
  int D.27161;
  <unnamed-unsigned:1> D.27162;
  int D.27163;
  unsigned char D.27168;
  unsigned int D.27169;
  <unnamed type> D.27175;
  signed char D.27180;
  unsigned int D.27181;
  char * D.27182;
  gchar * D.27183;
  gchar * D.27192;
  struct GSList * tmp;
  struct GSList * res;
  gboolean is_fulltrust;
  struct MonoLoaderError * error;

  D.27146 = BIT_FIELD_REF <*method, 32, 160>;
  D.27147 = D.27146 & 16384;
  if (D.27147 != 0) goto <D.27148>; else goto <D.27149>;
  <D.27148>:
  D.27150 = 0;
  return D.27150;
  <D.27149>:
  D.27151 = mono_verifier_is_enabled_for_method (method);
  if (D.27151 == 0) goto <D.27152>; else goto <D.27153>;
  <D.27152>:
  D.27150 = 0;
  return D.27150;
  <D.27153>:
  D.27158 = mono_verifier_is_method_full_trust (method);
  if (D.27158 != 0) goto <D.27155>; else goto <D.27159>;
  <D.27159>:
  D.27160 = cfg->domain;
  D.27161 = mini_assembly_can_skip_verification (D.27160, method);
  if (D.27161 != 0) goto <D.27155>; else goto <D.27156>;
  <D.27155>:
  iftmp.52 = 1;
  goto <D.27157>;
  <D.27156>:
  iftmp.52 = 0;
  <D.27157>:
  is_fulltrust = iftmp.52;
  D.27162 = cfg->skip_visibility;
  D.27163 = (int) D.27162;
  res = mono_method_verify_with_current_settings (method, D.27163, is_fulltrust);
  error = mono_loader_get_last_error ();
  if (error != 0B) goto <D.27164>; else goto <D.27165>;
  <D.27164>:
  if (fail_compile != 0) goto <D.27166>; else goto <D.27167>;
  <D.27166>:
  D.27168 = error->exception_type;
  D.27169 = (unsigned int) D.27168;
  cfg->exception_type = D.27169;
  goto <D.27170>;
  <D.27167>:
  mono_loader_clear_error ();
  <D.27170>:
  if (res != 0B) goto <D.27171>; else goto <D.27172>;
  <D.27171>:
  mono_free_verify_list (res);
  <D.27172>:
  D.27150 = 1;
  return D.27150;
  <D.27165>:
  if (res != 0B) goto <D.27173>; else goto <D.27174>;
  <D.27173>:
  tmp = res;
  goto <D.24601>;
  <D.24600>:
  {
    struct MonoVerifyInfoExtended * info;

    info = tmp->data;
    D.27175 = info->info.status;
    if (D.27175 == 1) goto <D.27176>; else goto <D.27177>;
    <D.27176>:
    if (fail_compile != 0) goto <D.27178>; else goto <D.27179>;
    <D.27178>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.27180 = info->exception_type;
      D.27181 = (unsigned int) D.27180;
      cfg->exception_type = D.27181;
      D.27182 = info->info.message;
      D.27183 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.27182);
      cfg->exception_message = D.27183;
      monoeg_g_free (method_name);
    }
    <D.27179>:
    mono_free_verify_list (res);
    D.27150 = 1;
    return D.27150;
    <D.27177>:
    D.27175 = info->info.status;
    if (D.27175 == 8) goto <D.27186>; else goto <D.27187>;
    <D.27186>:
    if (is_fulltrust == 0) goto <D.27184>; else goto <D.27188>;
    <D.27188>:
    D.27180 = info->exception_type;
    if (D.27180 == 9) goto <D.27184>; else goto <D.27189>;
    <D.27189>:
    D.27180 = info->exception_type;
    if (D.27180 == 10) goto <D.27184>; else goto <D.27185>;
    <D.27184>:
    if (fail_compile != 0) goto <D.27190>; else goto <D.27191>;
    <D.27190>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.27180 = info->exception_type;
      D.27181 = (unsigned int) D.27180;
      cfg->exception_type = D.27181;
      D.27182 = info->info.message;
      D.27192 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.27182);
      cfg->exception_message = D.27192;
      monoeg_g_free (method_name);
    }
    <D.27191>:
    mono_free_verify_list (res);
    D.27150 = 1;
    return D.27150;
    <D.27185>:
    <D.27187>:
  }
  tmp = tmp->next;
  <D.24601>:
  if (tmp != 0B) goto <D.24600>; else goto <D.24602>;
  <D.24602>:
  mono_free_verify_list (res);
  <D.27174>:
  method->verification_success = 1;
  D.27150 = 0;
  return D.27150;
}


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

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


mono_icall_get_wrapper_full (struct MonoJitICallInfo * callinfo, gboolean do_compile)
{
  const void * D.27196;
  const void * D.27199;
  const void * D.27200;
  union mono_mutex_t * D.27203;
  _Bool D.27206;
  long int D.27207;
  long int D.27208;
  _Bool D.27215;
  long int D.27216;
  long int D.27217;
  const char * D.27220;
  struct MonoMethodSignature * D.27221;
  const void * D.27222;
  int check_for_pending_exc.53;
  void * D.27227;
  _Bool D.27230;
  long int D.27231;
  long int D.27232;
  char * name;
  struct MonoMethod * wrapper;
  const void * trampoline;
  struct MonoDomain * domain;

  domain = mono_get_root_domain ();
  D.27196 = callinfo->wrapper;
  if (D.27196 != 0B) goto <D.27197>; else goto <D.27198>;
  <D.27197>:
  D.27199 = callinfo->wrapper;
  return D.27199;
  <D.27198>:
  D.27200 = callinfo->trampoline;
  if (D.27200 != 0B) goto <D.27201>; else goto <D.27202>;
  <D.27201>:
  D.27199 = callinfo->trampoline;
  return D.27199;
  <D.27202>:
  mono_loader_lock ();
  {
    int ret;

    D.27203 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.27203);
    if (ret != 0) goto <D.27204>; else goto <D.27205>;
    <D.27204>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27205>:
    D.27206 = ret != 0;
    D.27207 = (long int) D.27206;
    D.27208 = __builtin_expect (D.27207, 0);
    if (D.27208 != 0) goto <D.27209>; else goto <D.27210>;
    <D.27209>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1697, "ret == 0");
    <D.27210>:
  }
  D.27200 = callinfo->trampoline;
  if (D.27200 != 0B) goto <D.27211>; else goto <D.27212>;
  <D.27211>:
  {
    int ret;

    D.27203 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27203);
    if (ret != 0) goto <D.27213>; else goto <D.27214>;
    <D.27213>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27214>:
    D.27215 = ret != 0;
    D.27216 = (long int) D.27215;
    D.27217 = __builtin_expect (D.27216, 0);
    if (D.27217 != 0) goto <D.27218>; else goto <D.27219>;
    <D.27218>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1700, "ret == 0");
    <D.27219>:
  }
  mono_loader_unlock ();
  D.27199 = callinfo->trampoline;
  return D.27199;
  <D.27212>:
  D.27220 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.27220);
  D.27221 = callinfo->sig;
  D.27222 = callinfo->func;
  check_for_pending_exc.53 = check_for_pending_exc;
  wrapper = mono_marshal_get_icall_wrapper (D.27221, name, D.27222, check_for_pending_exc.53);
  monoeg_g_free (name);
  if (do_compile != 0) goto <D.27224>; else goto <D.27225>;
  <D.27224>:
  trampoline = mono_compile_method (wrapper);
  goto <D.27226>;
  <D.27225>:
  D.27227 = mono_create_jit_trampoline_in_domain (domain, wrapper);
  trampoline = mono_create_ftnptr (domain, D.27227);
  <D.27226>:
  mono_register_jit_icall_wrapper (callinfo, trampoline);
  callinfo->trampoline = trampoline;
  {
    int ret;

    D.27203 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27203);
    if (ret != 0) goto <D.27228>; else goto <D.27229>;
    <D.27228>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27229>:
    D.27230 = ret != 0;
    D.27231 = (long int) D.27230;
    D.27232 = __builtin_expect (D.27231, 0);
    if (D.27232 != 0) goto <D.27233>; else goto <D.27234>;
    <D.27233>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1717, "ret == 0");
    <D.27234>:
  }
  mono_loader_unlock ();
  D.27199 = callinfo->trampoline;
  return D.27199;
}


mono_allocate_stack_slots (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  unsigned int D.27236;
  struct MonoMethodVar * D.27239;
  struct MonoLiveInterval * D.27240;
  gint32 * D.27243;
  struct MonoMemPool * D.27244;
  unsigned int D.27245;
  unsigned int i.54;
  unsigned int D.27247;
  gint32 * D.27248;
  unsigned int i.55;
  unsigned int D.27250;
  struct MonoInst * * D.27251;
  struct MonoInst * * D.27252;
  unsigned int D.27253;
  unsigned char D.27256;
  int D.27257;
  int D.27258;
  short unsigned int D.27260;
  unsigned int D.27262;
  unsigned int D.27263;
  struct MonoInst * * D.27264;
  struct MonoType * D.27265;
  int D.27266;
  int D.27269;
  int D.27274;
  int D.27276;
  unsigned char D.27278;
  struct MonoClass * D.27280;
  int ialign.56;
  unsigned int ialign.57;
  struct MonoClass * D.27283;
  unsigned char D.27284;
  unsigned int D.27289;
  unsigned int D.27290;
  unsigned int D.27293;
  unsigned int D.27294;
  int D.27298;
  int D.27299;
  unsigned int D.27302;
  unsigned int D.27303;
  struct MonoClass * D.27306;
  unsigned int D.27307;
  struct StackSlotInfo * D.27308;
  struct MonoClass * D.27309;
  _Bool D.27314;
  long int D.27315;
  long int D.27316;
  unsigned int nvtypes.58;
  unsigned int D.27320;
  struct StackSlotInfo * D.27321;
  unsigned int D.27322;
  unsigned int D.27325;
  unsigned int D.27330;
  unsigned int D.27331;
  struct GList * D.27334;
  unsigned int D.27335;
  unsigned int D.27336;
  struct GList * D.27338;
  struct GSList * D.27339;
  unsigned int D.27340;
  unsigned int D.27341;
  gint32 * D.27342;
  int D.27343;
  void * D.27344;
  struct GSList * D.27345;
  int D.27346;
  void * D.27351;
  struct GSList * D.27352;
  struct GList * D.27353;
  int count.59;
  int count.60;
  int D.27356;
  int D.27363;
  unsigned int align.61;
  unsigned int align.62;
  guint32 iftmp.63;
  struct MonoClass * D.27369;
  int D.27370;
  unsigned int D.27371;
  struct MonoClass * D.27374;
  int D.27375;
  unsigned int size.64;
  unsigned int D.27378;
  unsigned int D.27379;
  unsigned int D.27380;
  unsigned int D.27381;
  unsigned int offset.65;
  unsigned int D.27385;
  unsigned int D.27386;
  unsigned int D.27387;
  unsigned int D.27389;
  unsigned int D.27390;
  gint32 * D.27391;
  struct StackSlotInfo * D.27392;
  struct GList * D.27393;
  struct GList * D.27396;
  int D.27399;
  int D.27400;
  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.27236 = cfg->num_varinfo;
      if (D.27236 != 0) goto <D.27237>; else goto <D.27238>;
      <D.27237>:
      D.27239 = cfg->vars;
      D.27240 = D.27239->interval;
      if (D.27240 != 0B) goto <D.27241>; else goto <D.27242>;
      <D.27241>:
      D.27243 = mono_allocate_stack_slots2 (cfg, backward, stack_size, stack_align);
      return D.27243;
      <D.27242>:
      <D.27238>:
      D.27244 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.27244, 1104);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.27244 = cfg->mempool;
      D.27236 = cfg->num_varinfo;
      D.27245 = D.27236 * 4;
      offsets = mono_mempool_alloc (D.27244, D.27245);
      i = 0;
      goto <D.24747>;
      <D.24746>:
      i.54 = (unsigned int) i;
      D.27247 = i.54 * 4;
      D.27248 = offsets + D.27247;
      *D.27248 = -1;
      i = i + 1;
      <D.24747>:
      i.55 = (unsigned int) i;
      D.27236 = cfg->num_varinfo;
      if (i.55 < D.27236) goto <D.24746>; else goto <D.24748>;
      <D.24748>:
      D.27250 = cfg->locals_start;
      i = (int) D.27250;
      goto <D.24751>;
      <D.24750>:
      D.27251 = cfg->varinfo;
      i.54 = (unsigned int) i;
      D.27247 = i.54 * 4;
      D.27252 = D.27251 + D.27247;
      inst = *D.27252;
      D.27239 = cfg->vars;
      i.54 = (unsigned int) i;
      D.27253 = i.54 * 56;
      vmv = D.27239 + D.27253;
      D.27256 = inst->flags;
      D.27257 = (int) D.27256;
      D.27258 = D.27257 & 2;
      if (D.27258 != 0) goto <D.27254>; else goto <D.27259>;
      <D.27259>:
      D.27260 = inst->opcode;
      if (D.27260 == 366) goto <D.27254>; else goto <D.27261>;
      <D.27261>:
      D.27260 = inst->opcode;
      if (D.27260 == 367) goto <D.27254>; else goto <D.27255>;
      <D.27254>:
      // predicted unlikely by continue predictor.
      goto <D.24749>;
      <D.27255>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.24749>:
      i = i + 1;
      <D.24751>:
      i.55 = (unsigned int) i;
      D.27236 = cfg->num_varinfo;
      if (i.55 < D.27236) goto <D.24750>; else goto <D.24752>;
      <D.24752>:
      vars = mono_varlist_sort (cfg, vars, 0);
      offset = 0;
      *stack_align = 4;
      l = vars;
      goto <D.24779>;
      <D.24778>:
      vmv = l->data;
      D.27251 = cfg->varinfo;
      D.27262 = vmv->idx;
      D.27263 = D.27262 * 4;
      D.27264 = D.27251 + D.27263;
      inst = *D.27264;
      D.27265 = inst->data.op[1].vtype;
      t = mono_type_get_underlying_type (D.27265);
      D.27266 = cfg->gsharedvt;
      if (D.27266 != 0) goto <D.27267>; else goto <D.27268>;
      <D.27267>:
      D.27269 = mini_is_gsharedvt_variable_type (cfg, t);
      if (D.27269 != 0) goto <D.27270>; else goto <D.27271>;
      <D.27270>:
      // predicted unlikely by continue predictor.
      goto <D.24753>;
      <D.27271>:
      <D.27268>:
      D.27274 = inst->backend.is_pinvoke;
      if (D.27274 != 0) goto <D.27275>; else goto <D.27272>;
      <D.27275>:
      D.27276 = mono_type_is_struct (t);
      if (D.27276 != 0) goto <D.27277>; else goto <D.27272>;
      <D.27277>:
      D.27278 = t->type;
      if (D.27278 != 22) goto <D.27279>; else goto <D.27272>;
      <D.27279>:
      D.27280 = mono_class_from_mono_type (t);
      size = mono_class_native_size (D.27280, &align);
      goto <D.27273>;
      <D.27272>:
      {
        int ialign;

        try
          {
            size = mono_type_size (t, &ialign);
            ialign.56 = ialign;
            ialign.57 = (unsigned int) ialign.56;
            align = ialign.57;
            D.27283 = mono_class_from_mono_type (t);
            D.27284 = D.27283->exception_type;
            if (D.27284 != 0) goto <D.27285>; else goto <D.27286>;
            <D.27285>:
            mono_cfg_set_exception (cfg, 7);
            <D.27286>:
            if (0 != 0) goto <D.27287>; else goto <D.27288>;
            <D.27287>:
            align = 16;
            <D.27288>:
          }
        finally
          {
            ialign = {CLOBBER};
          }
      }
      <D.27273>:
      reuse_slot = 1;
      D.27289 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.27290 = D.27289 & 65536;
      if (D.27290 != 0) goto <D.27291>; else goto <D.27292>;
      <D.27291>:
      reuse_slot = 0;
      <D.27292>:
      D.27293 = BIT_FIELD_REF <*t, 32, 32>;
      D.27294 = D.27293 & 1073741824;
      if (D.27294 != 0) goto <D.27295>; else goto <D.27296>;
      <D.27295>:
      slot_info = scalar_stack_slots + 384;
      goto <D.27297>;
      <D.27296>:
      D.27278 = t->type;
      D.27298 = (int) D.27278;
      switch (D.27298) <default: <D.24772>, case 8: <D.24764>, case 14: <D.24769>, case 15: <D.24761>, case 17: <D.24757>, case 18: <D.24765>, case 19: <D.24770>, case 20: <D.24767>, case 21: <D.24755>, case 24: <D.24762>, case 25: <D.24763>, case 28: <D.24766>, case 29: <D.24768>, case 30: <D.24771>>
      <D.24755>:
      D.27299 = mono_type_generic_inst_is_valuetype (t);
      if (D.27299 == 0) goto <D.27300>; else goto <D.27301>;
      <D.27300>:
      D.27278 = t->type;
      D.27302 = (unsigned int) D.27278;
      D.27303 = D.27302 * 16;
      slot_info = scalar_stack_slots + D.27303;
      goto <D.24756>;
      <D.27301>:
      <D.24757>:
      if (vtype_stack_slots == 0B) goto <D.27304>; else goto <D.27305>;
      <D.27304>:
      D.27244 = cfg->mempool;
      vtype_stack_slots = mono_mempool_alloc0 (D.27244, 4096);
      <D.27305>:
      i = 0;
      goto <D.24760>;
      <D.24759>:
      D.27306 = t->data.klass;
      i.54 = (unsigned int) i;
      D.27307 = i.54 * 16;
      D.27308 = vtype_stack_slots + D.27307;
      D.27309 = D.27308->vtype;
      if (D.27306 == D.27309) goto <D.24758>; else goto <D.27310>;
      <D.27310>:
      i = i + 1;
      <D.24760>:
      if (i < nvtypes) goto <D.24759>; else goto <D.24758>;
      <D.24758>:
      if (i < nvtypes) goto <D.27311>; else goto <D.27312>;
      <D.27311>:
      i.54 = (unsigned int) i;
      D.27307 = i.54 * 16;
      slot_info = vtype_stack_slots + D.27307;
      goto <D.27313>;
      <D.27312>:
      D.27314 = nvtypes > 255;
      D.27315 = (long int) D.27314;
      D.27316 = __builtin_expect (D.27315, 0);
      if (D.27316 != 0) goto <D.27317>; else goto <D.27318>;
      <D.27317>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2176, "nvtypes < 256");
      <D.27318>:
      nvtypes.58 = (unsigned int) nvtypes;
      D.27320 = nvtypes.58 * 16;
      D.27321 = vtype_stack_slots + D.27320;
      D.27306 = t->data.klass;
      D.27321->vtype = D.27306;
      nvtypes.58 = (unsigned int) nvtypes;
      D.27320 = nvtypes.58 * 16;
      slot_info = vtype_stack_slots + D.27320;
      nvtypes = nvtypes + 1;
      <D.27313>:
      D.27289 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.27322 = D.27289 & 131072;
      if (D.27322 != 0) goto <D.27323>; else goto <D.27324>;
      <D.27323>:
      reuse_slot = 0;
      <D.27324>:
      goto <D.24756>;
      <D.24761>:
      <D.24762>:
      <D.24763>:
      <D.24764>:
      D.27289 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.27325 = D.27289 & 262144;
      if (D.27325 != 0) goto <D.27326>; else goto <D.27327>;
      <D.27326>:
      slot_info = scalar_stack_slots + 384;
      goto <D.24756>;
      <D.27327>:
      <D.24765>:
      <D.24766>:
      <D.24767>:
      <D.24768>:
      <D.24769>:
      slot_info = scalar_stack_slots + 288;
      D.27289 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.27322 = D.27289 & 131072;
      if (D.27322 != 0) goto <D.27328>; else goto <D.27329>;
      <D.27328>:
      reuse_slot = 0;
      <D.27329>:
      goto <D.24756>;
      <D.24770>:
      <D.24771>:
      D.27278 = t->type;
      D.27302 = (unsigned int) D.27278;
      D.27303 = D.27302 * 16;
      slot_info = scalar_stack_slots + D.27303;
      goto <D.24756>;
      <D.24772>:
      D.27278 = t->type;
      D.27302 = (unsigned int) D.27278;
      D.27303 = D.27302 * 16;
      slot_info = scalar_stack_slots + D.27303;
      goto <D.24756>;
      <D.24756>:
      <D.27297>:
      slot = 16777215;
      D.27330 = cfg->comp_done;
      D.27331 = D.27330 & 16;
      if (D.27331 != 0) goto <D.27332>; else goto <D.27333>;
      <D.27332>:
      goto <D.24776>;
      <D.24775>:
      {
        struct MonoMethodVar * amv;

        D.27334 = slot_info->active;
        amv = D.27334->data;
        D.27335 = amv->range.last_use.abs_pos;
        D.27336 = vmv->range.first_use.abs_pos;
        if (D.27335 > D.27336) goto <D.24774>; else goto <D.27337>;
        <D.27337>:
        D.27334 = slot_info->active;
        D.27334 = slot_info->active;
        D.27338 = monoeg_g_list_delete_link (D.27334, D.27334);
        slot_info->active = D.27338;
        D.27244 = cfg->mempool;
        D.27339 = slot_info->slots;
        D.27340 = amv->idx;
        D.27341 = D.27340 * 4;
        D.27342 = offsets + D.27341;
        D.27343 = *D.27342;
        D.27344 = (void *) D.27343;
        D.27345 = g_slist_prepend_mempool (D.27244, D.27339, D.27344);
        slot_info->slots = D.27345;
      }
      <D.24776>:
      D.27334 = slot_info->active;
      if (D.27334 != 0B) goto <D.24775>; else goto <D.24774>;
      <D.24774>:
      D.27256 = inst->flags;
      D.27257 = (int) D.27256;
      D.27346 = D.27257 & 20;
      if (D.27346 == 0) goto <D.27347>; else goto <D.27348>;
      <D.27347>:
      D.27339 = slot_info->slots;
      if (D.27339 != 0B) goto <D.27349>; else goto <D.27350>;
      <D.27349>:
      D.27339 = slot_info->slots;
      D.27351 = D.27339->data;
      slot = (int) D.27351;
      D.27339 = slot_info->slots;
      D.27352 = D.27339->next;
      slot_info->slots = D.27352;
      <D.27350>:
      D.27334 = slot_info->active;
      D.27353 = mono_varlist_insert_sorted (cfg, D.27334, vmv, 1);
      slot_info->active = D.27353;
      <D.27348>:
      <D.27333>:
      {
        static int count = 0;

        count.59 = count;
        count.60 = count.59 + 1;
        count = count.60;
      }
      D.27256 = inst->flags;
      D.27257 = (int) D.27256;
      D.27356 = D.27257 & 32;
      if (D.27356 != 0) goto <D.27357>; else goto <D.27358>;
      <D.27357>:
      size = 276;
      align = 4;
      reuse_slot = 0;
      <D.27358>:
      if (reuse_slot == 0) goto <D.27359>; else goto <D.27360>;
      <D.27359>:
      slot = 16777215;
      <D.27360>:
      if (slot == 16777215) goto <D.27361>; else goto <D.27362>;
      <D.27361>:
      D.27363 = mono_type_is_struct (t);
      if (D.27363 != 0) goto <D.27364>; else goto <D.27365>;
      <D.27364>:
      align.61 = align;
      align.62 = MAX_EXPR <align.61, 4>;
      align = align.62;
      D.27369 = mono_class_from_mono_type (t);
      D.27370 = mono_class_min_align (D.27369);
      D.27371 = (unsigned int) D.27370;
      align.61 = align;
      if (D.27371 >= align.61) goto <D.27372>; else goto <D.27373>;
      <D.27372>:
      D.27374 = mono_class_from_mono_type (t);
      D.27375 = mono_class_min_align (D.27374);
      iftmp.63 = (guint32) D.27375;
      goto <D.27376>;
      <D.27373>:
      iftmp.63 = align;
      <D.27376>:
      align = iftmp.63;
      align.61 = align;
      size.64 = (unsigned int) size;
      D.27378 = align.61 + size.64;
      D.27379 = D.27378 + 4294967295;
      align.61 = align;
      D.27380 = -align.61;
      D.27381 = D.27379 & D.27380;
      size = (int) D.27381;
      <D.27365>:
      if (backward != 0) goto <D.27382>; else goto <D.27383>;
      <D.27382>:
      offset = offset + size;
      align.61 = align;
      offset.65 = (unsigned int) offset;
      D.27385 = align.61 + offset.65;
      D.27386 = D.27385 + 4294967295;
      offset = (int) D.27386;
      align.61 = align;
      D.27380 = -align.61;
      offset.65 = (unsigned int) offset;
      D.27387 = D.27380 & offset.65;
      offset = (int) D.27387;
      slot = offset;
      goto <D.27388>;
      <D.27383>:
      align.61 = align;
      offset.65 = (unsigned int) offset;
      D.27385 = align.61 + offset.65;
      D.27386 = D.27385 + 4294967295;
      offset = (int) D.27386;
      align.61 = align;
      D.27380 = -align.61;
      offset.65 = (unsigned int) offset;
      D.27387 = D.27380 & offset.65;
      offset = (int) D.27387;
      slot = offset;
      offset = offset + size;
      <D.27388>:
      D.27389 = *stack_align;
      align.61 = align;
      D.27390 = MAX_EXPR <D.27389, align.61>;
      *stack_align = D.27390;
      <D.27362>:
      D.27262 = vmv->idx;
      D.27263 = D.27262 * 4;
      D.27391 = offsets + D.27263;
      *D.27391 = slot;
      <D.24753>:
      l = l->next;
      <D.24779>:
      if (l != 0B) goto <D.24778>; else goto <D.24780>;
      <D.24780>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.24782>;
      <D.24781>:
      i.54 = (unsigned int) i;
      D.27307 = i.54 * 16;
      D.27392 = scalar_stack_slots + D.27307;
      D.27393 = D.27392->active;
      if (D.27393 != 0B) goto <D.27394>; else goto <D.27395>;
      <D.27394>:
      i.54 = (unsigned int) i;
      D.27307 = i.54 * 16;
      D.27392 = scalar_stack_slots + D.27307;
      D.27393 = D.27392->active;
      monoeg_g_list_free (D.27393);
      <D.27395>:
      i = i + 1;
      <D.24782>:
      if (i <= 68) goto <D.24781>; else goto <D.24783>;
      <D.24783>:
      i = 0;
      goto <D.24785>;
      <D.24784>:
      i.54 = (unsigned int) i;
      D.27307 = i.54 * 16;
      D.27308 = vtype_stack_slots + D.27307;
      D.27396 = D.27308->active;
      if (D.27396 != 0B) goto <D.27397>; else goto <D.27398>;
      <D.27397>:
      i.54 = (unsigned int) i;
      D.27307 = i.54 * 16;
      D.27308 = vtype_stack_slots + D.27307;
      D.27396 = D.27308->active;
      monoeg_g_list_free (D.27396);
      <D.27398>:
      i = i + 1;
      <D.24785>:
      if (i < nvtypes) goto <D.24784>; else goto <D.24786>;
      <D.24786>:
      D.27399 = cfg->stat_locals_stack_size;
      D.27400 = D.27399 + offset;
      cfg->stat_locals_stack_size = D.27400;
      offset.65 = (unsigned int) offset;
      *stack_size = offset.65;
      D.27243 = offsets;
      return D.27243;
    }
  finally
    {
      align = {CLOBBER};
    }
}


mono_allocate_stack_slots2 (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  struct MonoMemPool * D.27403;
  unsigned int D.27404;
  unsigned int D.27405;
  unsigned int i.66;
  unsigned int D.27407;
  gint32 * D.27408;
  unsigned int i.67;
  unsigned int D.27410;
  struct MonoInst * * D.27411;
  struct MonoInst * * D.27412;
  struct MonoMethodVar * D.27413;
  unsigned int D.27414;
  unsigned char D.27417;
  int D.27418;
  int D.27419;
  short unsigned int D.27421;
  struct GList * D.27423;
  unsigned int D.27424;
  unsigned int D.27425;
  struct MonoInst * * D.27426;
  struct MonoType * D.27427;
  int D.27428;
  int D.27431;
  int D.27436;
  int D.27438;
  unsigned char D.27440;
  struct MonoClass * D.27442;
  int ialign.68;
  unsigned int ialign.69;
  unsigned int D.27447;
  unsigned int D.27448;
  int D.27451;
  int D.27452;
  unsigned int D.27455;
  unsigned int D.27456;
  struct MonoClass * D.27459;
  unsigned int D.27460;
  struct StackSlotInfo * D.27461;
  struct MonoClass * D.27462;
  _Bool D.27467;
  long int D.27468;
  long int D.27469;
  unsigned int nvtypes.70;
  unsigned int D.27473;
  struct StackSlotInfo * D.27474;
  unsigned int D.27475;
  unsigned int D.27478;
  unsigned int D.27483;
  unsigned int D.27484;
  struct MonoLiveInterval * D.27487;
  struct MonoLiveRange2 * D.27488;
  int D.27491;
  unsigned char D.27495;
  struct MonoLiveInterval * D.27499;
  struct MonoLiveRange2 * D.27500;
  int D.27501;
  struct GList * D.27504;
  struct GList * D.27505;
  struct GSList * D.27506;
  unsigned int D.27507;
  unsigned int D.27508;
  gint32 * D.27509;
  int D.27510;
  void * D.27511;
  struct GSList * D.27512;
  int D.27513;
  struct GList * D.27516;
  struct GList * D.27517;
  struct GList * D.27518;
  struct MonoLiveInterval * D.27519;
  struct MonoLiveRange2 * D.27520;
  int D.27521;
  struct GList * D.27524;
  int D.27525;
  struct GList * D.27528;
  struct GList * D.27529;
  void * D.27534;
  struct GSList * D.27535;
  struct GList * D.27536;
  int D.27537;
  int D.27544;
  unsigned int align.71;
  unsigned int align.72;
  guint32 iftmp.73;
  struct MonoClass * D.27550;
  int D.27551;
  unsigned int D.27552;
  struct MonoClass * D.27555;
  int D.27556;
  unsigned int offset.74;
  unsigned int D.27561;
  unsigned int D.27562;
  unsigned int D.27563;
  unsigned int D.27564;
  unsigned int D.27566;
  gint32 * D.27569;
  struct StackSlotInfo * D.27570;
  struct GList * D.27571;
  struct GList * D.27574;
  int D.27577;
  int D.27578;
  gint32 * D.27579;
  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.27403 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.27403, 1104);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.27403 = cfg->mempool;
      D.27404 = cfg->num_varinfo;
      D.27405 = D.27404 * 4;
      offsets = mono_mempool_alloc (D.27403, D.27405);
      i = 0;
      goto <D.24674>;
      <D.24673>:
      i.66 = (unsigned int) i;
      D.27407 = i.66 * 4;
      D.27408 = offsets + D.27407;
      *D.27408 = -1;
      i = i + 1;
      <D.24674>:
      i.67 = (unsigned int) i;
      D.27404 = cfg->num_varinfo;
      if (i.67 < D.27404) goto <D.24673>; else goto <D.24675>;
      <D.24675>:
      D.27410 = cfg->locals_start;
      i = (int) D.27410;
      goto <D.24678>;
      <D.24677>:
      D.27411 = cfg->varinfo;
      i.66 = (unsigned int) i;
      D.27407 = i.66 * 4;
      D.27412 = D.27411 + D.27407;
      inst = *D.27412;
      D.27413 = cfg->vars;
      i.66 = (unsigned int) i;
      D.27414 = i.66 * 56;
      vmv = D.27413 + D.27414;
      D.27417 = inst->flags;
      D.27418 = (int) D.27417;
      D.27419 = D.27418 & 2;
      if (D.27419 != 0) goto <D.27415>; else goto <D.27420>;
      <D.27420>:
      D.27421 = inst->opcode;
      if (D.27421 == 366) goto <D.27415>; else goto <D.27422>;
      <D.27422>:
      D.27421 = inst->opcode;
      if (D.27421 == 367) goto <D.27415>; else goto <D.27416>;
      <D.27415>:
      // predicted unlikely by continue predictor.
      goto <D.24676>;
      <D.27416>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.24676>:
      i = i + 1;
      <D.24678>:
      i.67 = (unsigned int) i;
      D.27404 = cfg->num_varinfo;
      if (i.67 < D.27404) goto <D.24677>; else goto <D.24679>;
      <D.24679>:
      D.27423 = monoeg_g_list_copy (vars);
      vars = monoeg_g_list_sort (D.27423, compare_by_interval_start_pos_func);
      offset = 0;
      *stack_align = 0;
      unhandled = vars;
      goto <D.24716>;
      <D.24715>:
      {
        struct MonoMethodVar * current;

        current = unhandled->data;
        vmv = current;
        D.27411 = cfg->varinfo;
        D.27424 = vmv->idx;
        D.27425 = D.27424 * 4;
        D.27426 = D.27411 + D.27425;
        inst = *D.27426;
        D.27427 = inst->data.op[1].vtype;
        t = mono_type_get_underlying_type (D.27427);
        D.27428 = cfg->gsharedvt;
        if (D.27428 != 0) goto <D.27429>; else goto <D.27430>;
        <D.27429>:
        D.27431 = mini_is_gsharedvt_variable_type (cfg, t);
        if (D.27431 != 0) goto <D.27432>; else goto <D.27433>;
        <D.27432>:
        // predicted unlikely by continue predictor.
        goto <D.24681>;
        <D.27433>:
        <D.27430>:
        D.27436 = inst->backend.is_pinvoke;
        if (D.27436 != 0) goto <D.27437>; else goto <D.27434>;
        <D.27437>:
        D.27438 = mono_type_is_struct (t);
        if (D.27438 != 0) goto <D.27439>; else goto <D.27434>;
        <D.27439>:
        D.27440 = t->type;
        if (D.27440 != 22) goto <D.27441>; else goto <D.27434>;
        <D.27441>:
        D.27442 = mono_class_from_mono_type (t);
        size = mono_class_native_size (D.27442, &align);
        goto <D.27435>;
        <D.27434>:
        {
          int ialign;

          try
            {
              size = mono_type_size (t, &ialign);
              ialign.68 = ialign;
              ialign.69 = (unsigned int) ialign.68;
              align = ialign.69;
              if (0 != 0) goto <D.27445>; else goto <D.27446>;
              <D.27445>:
              align = 16;
              <D.27446>:
            }
          finally
            {
              ialign = {CLOBBER};
            }
        }
        <D.27435>:
        reuse_slot = 1;
        D.27447 = BIT_FIELD_REF <*cfg, 32, 3392>;
        D.27448 = D.27447 & 65536;
        if (D.27448 != 0) goto <D.27449>; else goto <D.27450>;
        <D.27449>:
        reuse_slot = 0;
        <D.27450>:
        D.27440 = t->type;
        D.27451 = (int) D.27440;
        switch (D.27451) <default: <D.24698>, case 8: <D.24692>, case 14: <D.24697>, case 15: <D.24689>, case 17: <D.24685>, case 18: <D.24693>, case 20: <D.24695>, case 21: <D.24683>, case 24: <D.24690>, case 25: <D.24691>, case 28: <D.24694>, case 29: <D.24696>>
        <D.24683>:
        D.27452 = mono_type_generic_inst_is_valuetype (t);
        if (D.27452 == 0) goto <D.27453>; else goto <D.27454>;
        <D.27453>:
        D.27440 = t->type;
        D.27455 = (unsigned int) D.27440;
        D.27456 = D.27455 * 16;
        slot_info = scalar_stack_slots + D.27456;
        goto <D.24684>;
        <D.27454>:
        <D.24685>:
        if (vtype_stack_slots == 0B) goto <D.27457>; else goto <D.27458>;
        <D.27457>:
        D.27403 = cfg->mempool;
        vtype_stack_slots = mono_mempool_alloc0 (D.27403, 4096);
        <D.27458>:
        i = 0;
        goto <D.24688>;
        <D.24687>:
        D.27459 = t->data.klass;
        i.66 = (unsigned int) i;
        D.27460 = i.66 * 16;
        D.27461 = vtype_stack_slots + D.27460;
        D.27462 = D.27461->vtype;
        if (D.27459 == D.27462) goto <D.24686>; else goto <D.27463>;
        <D.27463>:
        i = i + 1;
        <D.24688>:
        if (i < nvtypes) goto <D.24687>; else goto <D.24686>;
        <D.24686>:
        if (i < nvtypes) goto <D.27464>; else goto <D.27465>;
        <D.27464>:
        i.66 = (unsigned int) i;
        D.27460 = i.66 * 16;
        slot_info = vtype_stack_slots + D.27460;
        goto <D.27466>;
        <D.27465>:
        D.27467 = nvtypes > 255;
        D.27468 = (long int) D.27467;
        D.27469 = __builtin_expect (D.27468, 0);
        if (D.27469 != 0) goto <D.27470>; else goto <D.27471>;
        <D.27470>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1875, "nvtypes < 256");
        <D.27471>:
        nvtypes.70 = (unsigned int) nvtypes;
        D.27473 = nvtypes.70 * 16;
        D.27474 = vtype_stack_slots + D.27473;
        D.27459 = t->data.klass;
        D.27474->vtype = D.27459;
        nvtypes.70 = (unsigned int) nvtypes;
        D.27473 = nvtypes.70 * 16;
        slot_info = vtype_stack_slots + D.27473;
        nvtypes = nvtypes + 1;
        <D.27466>:
        D.27447 = BIT_FIELD_REF <*cfg, 32, 3392>;
        D.27475 = D.27447 & 131072;
        if (D.27475 != 0) goto <D.27476>; else goto <D.27477>;
        <D.27476>:
        reuse_slot = 0;
        <D.27477>:
        goto <D.24684>;
        <D.24689>:
        <D.24690>:
        <D.24691>:
        <D.24692>:
        D.27447 = BIT_FIELD_REF <*cfg, 32, 3392>;
        D.27478 = D.27447 & 262144;
        if (D.27478 != 0) goto <D.27479>; else goto <D.27480>;
        <D.27479>:
        slot_info = scalar_stack_slots + 384;
        goto <D.24684>;
        <D.27480>:
        <D.24693>:
        <D.24694>:
        <D.24695>:
        <D.24696>:
        <D.24697>:
        slot_info = scalar_stack_slots + 288;
        D.27447 = BIT_FIELD_REF <*cfg, 32, 3392>;
        D.27475 = D.27447 & 131072;
        if (D.27475 != 0) goto <D.27481>; else goto <D.27482>;
        <D.27481>:
        reuse_slot = 0;
        <D.27482>:
        goto <D.24684>;
        <D.24698>:
        D.27440 = t->type;
        D.27455 = (unsigned int) D.27440;
        D.27456 = D.27455 * 16;
        slot_info = scalar_stack_slots + D.27456;
        <D.24684>:
        slot = 16777215;
        D.27483 = cfg->comp_done;
        D.27484 = D.27483 & 16;
        if (D.27484 != 0) goto <D.27485>; else goto <D.27486>;
        <D.27485>:
        {
          int pos;
          gboolean changed;

          D.27487 = current->interval;
          D.27488 = D.27487->range;
          if (D.27488 == 0B) goto <D.27489>; else goto <D.27490>;
          <D.27489>:
          D.27417 = inst->flags;
          D.27418 = (int) D.27417;
          D.27491 = D.27418 & 20;
          if (D.27491 != 0) goto <D.27492>; else goto <D.27493>;
          <D.27492>:
          pos = -1;
          goto <D.27494>;
          <D.27493>:
          D.27417 = inst->flags;
          D.27495 = D.27417 | 2;
          inst->flags = D.27495;
          // predicted unlikely by continue predictor.
          goto <D.24681>;
          <D.27494>:
          goto <D.27496>;
          <D.27490>:
          D.27487 = current->interval;
          D.27488 = D.27487->range;
          pos = D.27488->from;
          <D.27496>:
          D.27487 = current->interval;
          D.27488 = D.27487->range;
          if (D.27488 != 0B) goto <D.27497>; else goto <D.27498>;
          <D.27497>:
          <D.27498>:
          changed = 1;
          goto <D.24706>;
          <D.24705>:
          changed = 0;
          l = slot_info->active;
          goto <D.24704>;
          <D.24703>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.27499 = v->interval;
            D.27500 = D.27499->last_range;
            D.27501 = D.27500->to;
            if (D.27501 < pos) goto <D.27502>; else goto <D.27503>;
            <D.27502>:
            D.27504 = slot_info->active;
            D.27505 = monoeg_g_list_delete_link (D.27504, l);
            slot_info->active = D.27505;
            D.27403 = cfg->mempool;
            D.27506 = slot_info->slots;
            D.27507 = v->idx;
            D.27508 = D.27507 * 4;
            D.27509 = offsets + D.27508;
            D.27510 = *D.27509;
            D.27511 = (void *) D.27510;
            D.27512 = g_slist_prepend_mempool (D.27403, D.27506, D.27511);
            slot_info->slots = D.27512;
            changed = 1;
            goto <D.24702>;
            <D.27503>:
            D.27499 = v->interval;
            D.27513 = mono_linterval_covers (D.27499, pos);
            if (D.27513 == 0) goto <D.27514>; else goto <D.27515>;
            <D.27514>:
            D.27516 = slot_info->inactive;
            D.27517 = monoeg_g_list_append (D.27516, v);
            slot_info->inactive = D.27517;
            D.27504 = slot_info->active;
            D.27518 = monoeg_g_list_delete_link (D.27504, l);
            slot_info->active = D.27518;
            changed = 1;
            goto <D.24702>;
            <D.27515>:
          }
          l = l->next;
          <D.24704>:
          if (l != 0B) goto <D.24703>; else goto <D.24702>;
          <D.24702>:
          <D.24706>:
          if (changed != 0) goto <D.24705>; else goto <D.24707>;
          <D.24707>:
          changed = 1;
          goto <D.24713>;
          <D.24712>:
          changed = 0;
          l = slot_info->inactive;
          goto <D.24711>;
          <D.24710>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.27519 = v->interval;
            D.27520 = D.27519->last_range;
            D.27521 = D.27520->to;
            if (D.27521 < pos) goto <D.27522>; else goto <D.27523>;
            <D.27522>:
            D.27516 = slot_info->inactive;
            D.27524 = monoeg_g_list_delete_link (D.27516, l);
            slot_info->inactive = D.27524;
            changed = 1;
            goto <D.24709>;
            <D.27523>:
            D.27519 = v->interval;
            D.27525 = mono_linterval_covers (D.27519, pos);
            if (D.27525 != 0) goto <D.27526>; else goto <D.27527>;
            <D.27526>:
            D.27504 = slot_info->active;
            D.27528 = monoeg_g_list_append (D.27504, v);
            slot_info->active = D.27528;
            D.27516 = slot_info->inactive;
            D.27529 = monoeg_g_list_delete_link (D.27516, l);
            slot_info->inactive = D.27529;
            changed = 1;
            goto <D.24709>;
            <D.27527>:
          }
          l = l->next;
          <D.24711>:
          if (l != 0B) goto <D.24710>; else goto <D.24709>;
          <D.24709>:
          <D.24713>:
          if (changed != 0) goto <D.24712>; else goto <D.24714>;
          <D.24714>:
          D.27417 = inst->flags;
          D.27418 = (int) D.27417;
          D.27491 = D.27418 & 20;
          if (D.27491 == 0) goto <D.27530>; else goto <D.27531>;
          <D.27530>:
          D.27506 = slot_info->slots;
          if (D.27506 != 0B) goto <D.27532>; else goto <D.27533>;
          <D.27532>:
          D.27506 = slot_info->slots;
          D.27534 = D.27506->data;
          slot = (int) D.27534;
          D.27506 = slot_info->slots;
          D.27535 = D.27506->next;
          slot_info->slots = D.27535;
          <D.27533>:
          D.27504 = slot_info->active;
          D.27536 = mono_varlist_insert_sorted (cfg, D.27504, vmv, 1);
          slot_info->active = D.27536;
          <D.27531>:
        }
        <D.27486>:
        D.27417 = inst->flags;
        D.27418 = (int) D.27417;
        D.27537 = D.27418 & 32;
        if (D.27537 != 0) goto <D.27538>; else goto <D.27539>;
        <D.27538>:
        size = 276;
        align = 4;
        reuse_slot = 0;
        <D.27539>:
        if (reuse_slot == 0) goto <D.27540>; else goto <D.27541>;
        <D.27540>:
        slot = 16777215;
        <D.27541>:
        if (slot == 16777215) goto <D.27542>; else goto <D.27543>;
        <D.27542>:
        D.27544 = mono_type_is_struct (t);
        if (D.27544 != 0) goto <D.27545>; else goto <D.27546>;
        <D.27545>:
        align.71 = align;
        align.72 = MAX_EXPR <align.71, 4>;
        align = align.72;
        D.27550 = mono_class_from_mono_type (t);
        D.27551 = mono_class_min_align (D.27550);
        D.27552 = (unsigned int) D.27551;
        align.71 = align;
        if (D.27552 >= align.71) goto <D.27553>; else goto <D.27554>;
        <D.27553>:
        D.27555 = mono_class_from_mono_type (t);
        D.27556 = mono_class_min_align (D.27555);
        iftmp.73 = (guint32) D.27556;
        goto <D.27557>;
        <D.27554>:
        iftmp.73 = align;
        <D.27557>:
        align = iftmp.73;
        <D.27546>:
        if (backward != 0) goto <D.27558>; else goto <D.27559>;
        <D.27558>:
        offset = offset + size;
        align.71 = align;
        offset.74 = (unsigned int) offset;
        D.27561 = align.71 + offset.74;
        D.27562 = D.27561 + 4294967295;
        offset = (int) D.27562;
        align.71 = align;
        D.27563 = -align.71;
        offset.74 = (unsigned int) offset;
        D.27564 = D.27563 & offset.74;
        offset = (int) D.27564;
        slot = offset;
        goto <D.27565>;
        <D.27559>:
        align.71 = align;
        offset.74 = (unsigned int) offset;
        D.27561 = align.71 + offset.74;
        D.27562 = D.27561 + 4294967295;
        offset = (int) D.27562;
        align.71 = align;
        D.27563 = -align.71;
        offset.74 = (unsigned int) offset;
        D.27564 = D.27563 & offset.74;
        offset = (int) D.27564;
        slot = offset;
        offset = offset + size;
        <D.27565>:
        D.27566 = *stack_align;
        if (D.27566 == 0) goto <D.27567>; else goto <D.27568>;
        <D.27567>:
        align.71 = align;
        *stack_align = align.71;
        <D.27568>:
        <D.27543>:
        D.27424 = vmv->idx;
        D.27425 = D.27424 * 4;
        D.27569 = offsets + D.27425;
        *D.27569 = slot;
      }
      <D.24681>:
      unhandled = unhandled->next;
      <D.24716>:
      if (unhandled != 0B) goto <D.24715>; else goto <D.24717>;
      <D.24717>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.24719>;
      <D.24718>:
      i.66 = (unsigned int) i;
      D.27460 = i.66 * 16;
      D.27570 = scalar_stack_slots + D.27460;
      D.27571 = D.27570->active;
      if (D.27571 != 0B) goto <D.27572>; else goto <D.27573>;
      <D.27572>:
      i.66 = (unsigned int) i;
      D.27460 = i.66 * 16;
      D.27570 = scalar_stack_slots + D.27460;
      D.27571 = D.27570->active;
      monoeg_g_list_free (D.27571);
      <D.27573>:
      i = i + 1;
      <D.24719>:
      if (i <= 68) goto <D.24718>; else goto <D.24720>;
      <D.24720>:
      i = 0;
      goto <D.24722>;
      <D.24721>:
      i.66 = (unsigned int) i;
      D.27460 = i.66 * 16;
      D.27461 = vtype_stack_slots + D.27460;
      D.27574 = D.27461->active;
      if (D.27574 != 0B) goto <D.27575>; else goto <D.27576>;
      <D.27575>:
      i.66 = (unsigned int) i;
      D.27460 = i.66 * 16;
      D.27461 = vtype_stack_slots + D.27460;
      D.27574 = D.27461->active;
      monoeg_g_list_free (D.27574);
      <D.27576>:
      i = i + 1;
      <D.24722>:
      if (i < nvtypes) goto <D.24721>; else goto <D.24723>;
      <D.24723>:
      D.27577 = cfg->stat_locals_stack_size;
      D.27578 = D.27577 + offset;
      cfg->stat_locals_stack_size = D.27578;
      offset.74 = (unsigned int) offset;
      *stack_size = offset.74;
      D.27579 = offsets;
      return D.27579;
    }
  finally
    {
      align = {CLOBBER};
    }
}


compare_by_interval_start_pos_func (const void * a, const void * b)
{
  gint D.27584;
  struct MonoLiveInterval * D.27586;
  struct MonoLiveRange2 * D.27587;
  struct MonoLiveInterval * D.27589;
  struct MonoLiveRange2 * D.27590;
  int D.27592;
  int D.27593;
  struct MonoMethodVar * v1;
  struct MonoMethodVar * v2;

  v1 = a;
  v2 = b;
  if (v1 == v2) goto <D.27582>; else goto <D.27583>;
  <D.27582>:
  D.27584 = 0;
  return D.27584;
  <D.27583>:
  D.27586 = v1->interval;
  D.27587 = D.27586->range;
  if (D.27587 != 0B) goto <D.27588>; else goto <D.27585>;
  <D.27588>:
  D.27589 = v2->interval;
  D.27590 = D.27589->range;
  if (D.27590 != 0B) goto <D.27591>; else goto <D.27585>;
  <D.27591>:
  D.27586 = v1->interval;
  D.27587 = D.27586->range;
  D.27592 = D.27587->from;
  D.27589 = v2->interval;
  D.27590 = D.27589->range;
  D.27593 = D.27590->from;
  D.27584 = D.27592 - D.27593;
  return D.27584;
  <D.27585>:
  D.27586 = v1->interval;
  D.27587 = D.27586->range;
  if (D.27587 != 0B) goto <D.27594>; else goto <D.27595>;
  <D.27594>:
  D.27584 = -1;
  return D.27584;
  <D.27595>:
  D.27584 = 1;
  return D.27584;
}


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

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


mono_find_jit_opcode_emulation (int opcode)
{
  unsigned int opcode.75;
  _Bool D.27600;
  long int D.27601;
  long int D.27602;
  int D.27605;
  unsigned char D.27606;
  int D.27607;
  int D.27608;
  int D.27609;
  int D.27610;
  short int * emul_opcode_opcodes.76;
  unsigned int i.77;
  unsigned int D.27615;
  short int * D.27616;
  short int D.27617;
  int D.27618;
  struct MonoJitICallInfo * D.27621;
  struct MonoJitICallInfo * * emul_opcode_map.78;
  unsigned int D.27623;
  struct MonoJitICallInfo * * D.27624;
  short int emul_opcode_num.79;
  int D.27626;

  opcode.75 = (unsigned int) opcode;
  D.27600 = opcode.75 > 901;
  D.27601 = (long int) D.27600;
  D.27602 = __builtin_expect (D.27601, 0);
  if (D.27602 != 0) goto <D.27603>; else goto <D.27604>;
  <D.27603>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2356, "opcode >= 0 && opcode <= OP_LAST");
  <D.27604>:
  D.27605 = opcode >> 6;
  D.27606 = emul_opcode_hit_cache[D.27605];
  D.27607 = (int) D.27606;
  D.27608 = opcode & 7;
  D.27609 = D.27607 >> D.27608;
  D.27610 = D.27609 & 1;
  if (D.27610 != 0) goto <D.27611>; else goto <D.27612>;
  <D.27611>:
  {
    int i;

    i = 0;
    goto <D.24797>;
    <D.24796>:
    emul_opcode_opcodes.76 = emul_opcode_opcodes;
    i.77 = (unsigned int) i;
    D.27615 = i.77 * 2;
    D.27616 = emul_opcode_opcodes.76 + D.27615;
    D.27617 = *D.27616;
    D.27618 = (int) D.27617;
    if (D.27618 == opcode) goto <D.27619>; else goto <D.27620>;
    <D.27619>:
    emul_opcode_map.78 = emul_opcode_map;
    i.77 = (unsigned int) i;
    D.27623 = i.77 * 4;
    D.27624 = emul_opcode_map.78 + D.27623;
    D.27621 = *D.27624;
    return D.27621;
    <D.27620>:
    i = i + 1;
    <D.24797>:
    emul_opcode_num.79 = emul_opcode_num;
    D.27626 = (int) emul_opcode_num.79;
    if (D.27626 > i) goto <D.24796>; else goto <D.24798>;
    <D.24798>:
  }
  <D.27612>:
  D.27621 = 0B;
  return D.27621;
}


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

  D.27628 = bb->last_ins;
  if (D.27628 != 0B) goto <D.27629>; else goto <D.27630>;
  <D.27629>:
  D.27628 = bb->last_ins;
  D.27628->next = inst;
  D.27628 = bb->last_ins;
  inst->prev = D.27628;
  bb->last_ins = inst;
  goto <D.27631>;
  <D.27630>:
  bb->last_ins = inst;
  D.27628 = bb->last_ins;
  bb->code = D.27628;
  <D.27631>:
}


mono_bblock_insert_after_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.27636;
  struct MonoInst * D.27640;

  if (ins == 0B) goto <D.27632>; else goto <D.27633>;
  <D.27632>:
  ins = bb->code;
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  if (ins != 0B) goto <D.27634>; else goto <D.27635>;
  <D.27634>:
  ins->prev = ins_to_insert;
  <D.27635>:
  D.27636 = bb->last_ins;
  if (D.27636 == 0B) goto <D.27637>; else goto <D.27638>;
  <D.27637>:
  bb->last_ins = ins_to_insert;
  <D.27638>:
  goto <D.27639>;
  <D.27633>:
  D.27640 = ins->next;
  ins_to_insert->next = D.27640;
  D.27640 = ins->next;
  if (D.27640 != 0B) goto <D.27641>; else goto <D.27642>;
  <D.27641>:
  D.27640 = ins->next;
  D.27640->prev = ins_to_insert;
  <D.27642>:
  ins->next = ins_to_insert;
  ins_to_insert->prev = ins;
  D.27636 = bb->last_ins;
  if (D.27636 == ins) goto <D.27643>; else goto <D.27644>;
  <D.27643>:
  bb->last_ins = ins_to_insert;
  <D.27644>:
  <D.27639>:
}


mono_bblock_insert_before_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.27649;
  struct MonoInst * D.27653;
  struct MonoInst * D.27656;

  if (ins == 0B) goto <D.27645>; else goto <D.27646>;
  <D.27645>:
  ins = bb->code;
  if (ins != 0B) goto <D.27647>; else goto <D.27648>;
  <D.27647>:
  ins->prev = ins_to_insert;
  <D.27648>:
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  D.27649 = bb->last_ins;
  if (D.27649 == 0B) goto <D.27650>; else goto <D.27651>;
  <D.27650>:
  bb->last_ins = ins_to_insert;
  <D.27651>:
  goto <D.27652>;
  <D.27646>:
  D.27653 = ins->prev;
  if (D.27653 != 0B) goto <D.27654>; else goto <D.27655>;
  <D.27654>:
  D.27653 = ins->prev;
  D.27653->next = ins_to_insert;
  <D.27655>:
  D.27653 = ins->prev;
  ins_to_insert->prev = D.27653;
  ins->prev = ins_to_insert;
  ins_to_insert->next = ins;
  D.27656 = bb->code;
  if (D.27656 == ins) goto <D.27657>; else goto <D.27658>;
  <D.27657>:
  bb->code = ins_to_insert;
  <D.27658>:
  <D.27652>:
}


mono_verify_bblock (struct MonoBasicBlock * bb)
{
  struct MonoInst * D.27659;
  _Bool D.27660;
  long int D.27661;
  long int D.27662;
  struct MonoInst * D.27665;
  struct MonoInst * D.27668;
  _Bool D.27669;
  long int D.27670;
  long int D.27671;
  struct MonoInst * ins;
  struct MonoInst * prev;

  prev = 0B;
  ins = bb->code;
  goto <D.24865>;
  <D.24864>:
  D.27659 = ins->prev;
  D.27660 = D.27659 != prev;
  D.27661 = (long int) D.27660;
  D.27662 = __builtin_expect (D.27661, 0);
  if (D.27662 != 0) goto <D.27663>; else goto <D.27664>;
  <D.27663>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2550, "ins->prev == prev");
  <D.27664>:
  prev = ins;
  ins = ins->next;
  <D.24865>:
  if (ins != 0B) goto <D.24864>; else goto <D.24866>;
  <D.24866>:
  D.27665 = bb->last_ins;
  if (D.27665 != 0B) goto <D.27666>; else goto <D.27667>;
  <D.27666>:
  D.27665 = bb->last_ins;
  D.27668 = D.27665->next;
  D.27669 = D.27668 != 0B;
  D.27670 = (long int) D.27669;
  D.27671 = __builtin_expect (D.27670, 0);
  if (D.27671 != 0) goto <D.27672>; else goto <D.27673>;
  <D.27672>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2554, "!bb->last_ins->next");
  <D.27673>:
  <D.27667>:
}


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

  bb = cfg->bb_entry;
  goto <D.24872>;
  <D.24871>:
  mono_verify_bblock (bb);
  bb = bb->next_bb;
  <D.24872>:
  if (bb != 0B) goto <D.24871>; else goto <D.24873>;
  <D.24873>:
}


mono_destroy_compile (struct MonoCompile * cfg)
{
  struct MonoMethodHeader * D.27674;
  struct MonoRegState * D.27677;
  struct GHashTable * D.27680;
  struct GHashTable * D.27683;
  void * D.27686;
  struct GList * D.27687;
  struct GHashTable * D.27688;
  struct GHashTable * D.27689;
  struct MonoMemPool * D.27692;
  struct MonoInst * * D.27693;
  struct MonoMethodVar * D.27694;
  char * D.27695;
  struct GSList * l;

  D.27674 = cfg->header;
  if (D.27674 != 0B) goto <D.27675>; else goto <D.27676>;
  <D.27675>:
  D.27674 = cfg->header;
  mono_metadata_free_mh (D.27674);
  <D.27676>:
  mono_free_loop_info (cfg);
  D.27677 = cfg->rs;
  if (D.27677 != 0B) goto <D.27678>; else goto <D.27679>;
  <D.27678>:
  D.27677 = cfg->rs;
  mono_regstate_free (D.27677);
  <D.27679>:
  D.27680 = cfg->spvars;
  if (D.27680 != 0B) goto <D.27681>; else goto <D.27682>;
  <D.27681>:
  D.27680 = cfg->spvars;
  monoeg_g_hash_table_destroy (D.27680);
  <D.27682>:
  D.27683 = cfg->exvars;
  if (D.27683 != 0B) goto <D.27684>; else goto <D.27685>;
  <D.27684>:
  D.27683 = cfg->exvars;
  monoeg_g_hash_table_destroy (D.27683);
  <D.27685>:
  l = cfg->headers_to_free;
  goto <D.24879>;
  <D.24878>:
  D.27686 = l->data;
  mono_metadata_free_mh (D.27686);
  l = l->next;
  <D.24879>:
  if (l != 0B) goto <D.24878>; else goto <D.24880>;
  <D.24880>:
  D.27687 = cfg->ldstr_list;
  monoeg_g_list_free (D.27687);
  D.27688 = cfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.27688);
  D.27689 = cfg->abs_patches;
  if (D.27689 != 0B) goto <D.27690>; else goto <D.27691>;
  <D.27690>:
  D.27689 = cfg->abs_patches;
  monoeg_g_hash_table_destroy (D.27689);
  <D.27691>:
  D.27692 = cfg->mempool;
  mono_mempool_destroy (D.27692);
  mono_debug_free_method (cfg);
  D.27693 = cfg->varinfo;
  monoeg_g_free (D.27693);
  D.27694 = cfg->vars;
  monoeg_g_free (D.27694);
  D.27695 = cfg->exception_message;
  monoeg_g_free (D.27695);
  monoeg_g_free (cfg);
}


mono_get_jit_tls_key ()
{
  pthread_key_t D.27696;

  D.27696 = mono_jit_tls_id;
  return D.27696;
}


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

  offset = -1;
  D.27698 = offset;
  return D.27698;
}


mono_get_lmf_tls_offset ()
{
  gint32 D.27700;

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


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

  offset = -1;
  D.27702 = offset;
  return D.27702;
}


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

  mono_jit_tls_id.80 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.80);
  if (jit_tls != 0B) goto <D.27705>; else goto <D.27706>;
  <D.27705>:
  D.27707 = jit_tls->lmf;
  return D.27707;
  <D.27706>:
  D.27707 = 0B;
  return D.27707;
}


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

  D.27709 = mono_lmf_addr;
  return D.27709;
}


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

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


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

  if (domain == 0B) goto <D.27712>; else goto <D.27713>;
  <D.27712>:
  domain = mono_get_root_domain ();
  <D.27713>:
  mono_lmf_addr.81 = mono_lmf_addr;
  if (mono_lmf_addr.81 == 0B) goto <D.27715>; else goto <D.27716>;
  <D.27715>:
  mono_thread_attach (domain);
  D.27717 = mono_thread_internal_current ();
  mono_thread_set_state (D.27717, 4);
  <D.27716>:
  orig = mono_domain_get ();
  if (orig != domain) goto <D.27718>; else goto <D.27719>;
  <D.27718>:
  mono_domain_set (domain, 1);
  <D.27719>:
  if (orig != domain) goto <D.27722>; else goto <D.27723>;
  <D.27722>:
  iftmp.82 = orig;
  goto <D.27724>;
  <D.27723>:
  iftmp.82 = 0B;
  <D.27724>:
  D.27720 = iftmp.82;
  return D.27720;
}


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


mini_get_tls_offset (MonoTlsKey key)
{
  _Bool D.27728;
  long int D.27729;
  long int D.27730;
  int D.27733;
  int offset;

  switch (key) <default: <D.24963>, case 0: <D.24957>, case 1: <D.24959>, case 2: <D.24960>, case 3: <D.24961>, case 8: <D.24962>>
  <D.24957>:
  offset = mono_thread_get_tls_offset ();
  goto <D.24958>;
  <D.24959>:
  offset = mono_get_jit_tls_offset ();
  goto <D.24958>;
  <D.24960>:
  offset = mono_domain_get_tls_offset ();
  goto <D.24958>;
  <D.24961>:
  offset = mono_get_lmf_tls_offset ();
  goto <D.24958>;
  <D.24962>:
  offset = mono_get_lmf_addr_tls_offset ();
  goto <D.24958>;
  <D.24963>:
  offset = mono_tls_key_get_offset (key);
  D.27728 = offset == -1;
  D.27729 = (long int) D.27728;
  D.27730 = __builtin_expect (D.27729, 0);
  if (D.27730 != 0) goto <D.27731>; else goto <D.27732>;
  <D.27731>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2929, "offset != -1");
  <D.27732>:
  goto <D.24958>;
  <D.24958>:
  D.27733 = offset;
  return D.27733;
}


mini_tls_get_supported (struct MonoCompile * cfg, MonoTlsKey key)
{
  gboolean D.27737;
  unsigned int D.27738;
  unsigned int D.27739;
  int D.27742;
  _Bool D.27743;

  if (1 != 0) goto <D.27735>; else goto <D.27736>;
  <D.27735>:
  D.27737 = 0;
  return D.27737;
  <D.27736>:
  D.27738 = BIT_FIELD_REF <*cfg, 32, 3392>;
  D.27739 = D.27738 & 64;
  if (D.27739 != 0) goto <D.27740>; else goto <D.27741>;
  <D.27740>:
  D.27737 = 0;
  return D.27737;
  <D.27741>:
  D.27742 = mini_get_tls_offset (key);
  D.27743 = D.27742 != -1;
  D.27737 = (gboolean) D.27743;
  return D.27737;
}


mono_create_tls_get (struct MonoCompile * cfg, MonoTlsKey key)
{
  unsigned int D.27745;
  unsigned int D.27746;
  struct MonoMemPool * D.27753;
  int D.27754;
  struct MonoInst * D.27755;
  guint16 iftmp.83;
  int D.27760;
  int D.27761;
  const unsigned char * D.27762;
  void * key.84;
  unsigned int D.27764;
  int D.27765;
  void * _offset.85;
  unsigned int D.27768;
  int D.27769;
  struct MonoBasicBlock * D.27770;
  struct MonoInst * D.27771;
  int D.27775;
  struct MonoInst * D.27776;
  int D.27777;
  int D.27778;
  unsigned int D.27779;
  int D.27780;
  int D.27781;
  struct MonoInst * D.27782;
  int D.27783;

  D.27745 = BIT_FIELD_REF <*cfg, 32, 3392>;
  D.27746 = D.27745 & 64;
  if (D.27746 != 0) goto <D.27747>; else goto <D.27748>;
  <D.27747>:
  if (0 != 0) goto <D.27749>; else goto <D.27750>;
  <D.27749>:
  {
    struct MonoInst * ins;
    struct MonoInst * c;

    D.27745 = BIT_FIELD_REF <*cfg, 32, 3392>;
    D.27746 = D.27745 & 64;
    if (D.27746 != 0) goto <D.27751>; else goto <D.27752>;
    <D.27751>:
    D.27753 = cfg->mempool;
    c = mono_mempool_alloc (D.27753, 56);
    c->data.op[1].const_val = 0;
    D.27754 = c->data.op[1].const_val;
    c->data.op[0].const_val = D.27754;
    c->prev = 0B;
    D.27755 = c->prev;
    c->next = D.27755;
    D.27745 = BIT_FIELD_REF <*cfg, 32, 3392>;
    D.27746 = D.27745 & 64;
    if (D.27746 != 0) goto <D.27757>; else goto <D.27758>;
    <D.27757>:
    iftmp.83 = 732;
    goto <D.27759>;
    <D.27758>:
    iftmp.83 = 362;
    <D.27759>:
    c->opcode = iftmp.83;
    c->flags = 0;
    c->type = 0;
    c->dreg = -1;
    c->sreg3 = -1;
    D.27760 = c->sreg3;
    c->sreg2 = D.27760;
    D.27761 = c->sreg2;
    c->sreg1 = D.27761;
    D.27762 = cfg->ip;
    c->cil_code = D.27762;
    key.84 = (void *) key;
    c->data.op[0].p = key.84;
    c->data.op[1].src = 48B;
    c->type = 3;
    D.27764 = alloc_dreg (cfg, 3);
    D.27765 = (int) D.27764;
    c->dreg = D.27765;
    goto <D.27766>;
    <D.27752>:
    {
      int _offset;

      _offset = mini_get_tls_offset (key);
      D.27753 = cfg->mempool;
      c = mono_mempool_alloc (D.27753, 56);
      c->data.op[1].const_val = 0;
      D.27754 = c->data.op[1].const_val;
      c->data.op[0].const_val = D.27754;
      c->prev = 0B;
      D.27755 = c->prev;
      c->next = D.27755;
      c->opcode = 362;
      c->flags = 0;
      c->type = 0;
      c->dreg = -1;
      c->sreg3 = -1;
      D.27760 = c->sreg3;
      c->sreg2 = D.27760;
      D.27761 = c->sreg2;
      c->sreg1 = D.27761;
      D.27762 = cfg->ip;
      c->cil_code = D.27762;
      _offset.85 = (void *) _offset;
      c->data.op[0].p = _offset.85;
      c->type = 3;
      D.27768 = alloc_dreg (cfg, 3);
      D.27769 = (int) D.27768;
      c->dreg = D.27769;
    }
    <D.27766>:
    D.27770 = cfg->cbb;
    D.27771 = D.27770->last_ins;
    if (D.27771 != 0B) goto <D.27772>; else goto <D.27773>;
    <D.27772>:
    D.27770 = cfg->cbb;
    D.27771 = D.27770->last_ins;
    D.27771->next = c;
    D.27770 = cfg->cbb;
    D.27771 = D.27770->last_ins;
    c->prev = D.27771;
    D.27770 = cfg->cbb;
    D.27770->last_ins = c;
    goto <D.27774>;
    <D.27773>:
    D.27770 = cfg->cbb;
    D.27770 = cfg->cbb;
    D.27770->last_ins = c;
    D.27771 = D.27770->last_ins;
    D.27770->code = D.27771;
    <D.27774>:
    D.27753 = cfg->mempool;
    ins = mono_mempool_alloc (D.27753, 56);
    ins->data.op[1].const_val = 0;
    D.27775 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.27775;
    ins->prev = 0B;
    D.27776 = ins->prev;
    ins->next = D.27776;
    ins->opcode = 792;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.27777 = ins->sreg3;
    ins->sreg2 = D.27777;
    D.27778 = ins->sreg2;
    ins->sreg1 = D.27778;
    D.27762 = cfg->ip;
    ins->cil_code = D.27762;
    D.27779 = mono_alloc_preg (cfg);
    D.27780 = (int) D.27779;
    ins->dreg = D.27780;
    D.27781 = c->dreg;
    ins->sreg1 = D.27781;
    D.27782 = ins;
    return D.27782;
  }
  <D.27750>:
  D.27782 = 0B;
  return D.27782;
  <D.27748>:
  D.27783 = mini_get_tls_offset (key);
  D.27782 = mono_create_tls_get_offset (cfg, D.27783);
  return D.27782;
}


mono_create_tls_get_offset (struct MonoCompile * cfg, int offset)
{
  struct MonoInst * D.27787;
  struct MonoMemPool * D.27790;
  int D.27791;
  struct MonoInst * D.27792;
  int D.27793;
  int D.27794;
  const unsigned char * D.27795;
  unsigned int D.27796;
  int D.27797;
  struct MonoInst * ins;

  if (1 != 0) goto <D.27785>; else goto <D.27786>;
  <D.27785>:
  D.27787 = 0B;
  return D.27787;
  <D.27786>:
  if (offset == -1) goto <D.27788>; else goto <D.27789>;
  <D.27788>:
  D.27787 = 0B;
  return D.27787;
  <D.27789>:
  D.27790 = cfg->mempool;
  ins = mono_mempool_alloc (D.27790, 56);
  ins->data.op[1].const_val = 0;
  D.27791 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.27791;
  ins->prev = 0B;
  D.27792 = ins->prev;
  ins->next = D.27792;
  ins->opcode = 791;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.27793 = ins->sreg3;
  ins->sreg2 = D.27793;
  D.27794 = ins->sreg2;
  ins->sreg1 = D.27794;
  D.27795 = cfg->ip;
  ins->cil_code = D.27795;
  D.27796 = mono_alloc_preg (cfg);
  D.27797 = (int) D.27796;
  ins->dreg = D.27797;
  ins->data.op[0].const_val = offset;
  D.27787 = ins;
  return D.27787;
}


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


mono_remove_patch_info (struct MonoCompile * cfg, int ip)
{
  struct MonoJumpInfo * D.27815;
  int D.27816;
  struct MonoJumpInfo * D.27819;
  struct MonoJumpInfo * * ji;

  ji = &cfg->patch_info;
  goto <D.25023>;
  <D.25022>:
  D.27815 = *ji;
  D.27816 = D.27815->ip.i;
  if (D.27816 == ip) goto <D.27817>; else goto <D.27818>;
  <D.27817>:
  D.27815 = *ji;
  D.27819 = D.27815->next;
  *ji = D.27819;
  goto <D.27820>;
  <D.27818>:
  D.27815 = *ji;
  ji = &D.27815->next;
  <D.27820>:
  <D.25023>:
  D.27815 = *ji;
  if (D.27815 != 0B) goto <D.25022>; else goto <D.25024>;
  <D.25024>:
}


mono_patch_info_dup_mp (struct MonoMemPool * mp, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.27821;
  void * D.27822;
  struct MonoJumpInfoToken * D.27823;
  struct MonoJumpInfoToken * D.27824;
  void * D.27825;
  struct MonoJumpInfoBBTable * D.27826;
  struct MonoJumpInfoBBTable * D.27827;
  int D.27828;
  unsigned int D.27829;
  unsigned int D.27830;
  void * D.27831;
  struct MonoBasicBlock * * D.27832;
  struct MonoBasicBlock * * D.27833;
  void * D.27834;
  struct MonoJumpInfoRgctxEntry * D.27835;
  struct MonoJumpInfoRgctxEntry * D.27836;
  struct MonoJumpInfo * D.27837;
  struct MonoJumpInfo * D.27838;
  void * D.27839;
  struct MonoJumpInfoGSharedVtCall * D.27840;
  struct MonoJumpInfoGSharedVtCall * D.27841;
  struct GPtrArray * D.27842;
  struct GPtrArray * D.27843;
  void * * D.27846;
  unsigned int i.86;
  unsigned int D.27848;
  void * * D.27849;
  struct GPtrArray * D.27850;
  unsigned int i.87;
  unsigned int D.27852;
  struct MonoJumpInfo * D.27853;
  struct MonoJumpInfo * res;

  res = mono_mempool_alloc (mp, 20);
  memcpy (res, patch_info, 20);
  D.27821 = patch_info->type;
  switch (D.27821) <default: <D.25048>, case 8: <D.25036>, case 17: <D.25031>, case 18: <D.25033>, case 19: <D.25032>, case 28: <D.25034>, case 29: <D.25030>, case 35: <D.25037>, case 45: <D.25038>, case 46: <D.25039>>
  <D.25030>:
  <D.25031>:
  <D.25032>:
  <D.25033>:
  <D.25034>:
  D.27822 = mono_mempool_alloc (mp, 20);
  res->data.token = D.27822;
  D.27823 = res->data.token;
  D.27824 = patch_info->data.token;
  memcpy (D.27823, D.27824, 20);
  goto <D.25035>;
  <D.25036>:
  D.27825 = mono_mempool_alloc (mp, 8);
  res->data.table = D.27825;
  D.27826 = res->data.table;
  D.27827 = patch_info->data.table;
  memcpy (D.27826, D.27827, 8);
  D.27826 = res->data.table;
  D.27827 = patch_info->data.table;
  D.27828 = D.27827->table_size;
  D.27829 = (unsigned int) D.27828;
  D.27830 = D.27829 * 4;
  D.27831 = mono_mempool_alloc (mp, D.27830);
  D.27826->table = D.27831;
  D.27826 = res->data.table;
  D.27832 = D.27826->table;
  D.27827 = patch_info->data.table;
  D.27833 = D.27827->table;
  D.27827 = patch_info->data.table;
  D.27828 = D.27827->table_size;
  D.27829 = (unsigned int) D.27828;
  D.27830 = D.27829 * 4;
  memcpy (D.27832, D.27833, D.27830);
  goto <D.25035>;
  <D.25037>:
  D.27834 = mono_mempool_alloc (mp, 16);
  res->data.rgctx_entry = D.27834;
  D.27835 = res->data.rgctx_entry;
  D.27836 = patch_info->data.rgctx_entry;
  memcpy (D.27835, D.27836, 16);
  D.27835 = res->data.rgctx_entry;
  D.27835 = res->data.rgctx_entry;
  D.27837 = D.27835->data;
  D.27838 = mono_patch_info_dup_mp (mp, D.27837);
  D.27835->data = D.27838;
  goto <D.25035>;
  <D.25038>:
  D.27839 = mono_mempool_alloc (mp, 8);
  res->data.gsharedvt = D.27839;
  D.27840 = res->data.gsharedvt;
  D.27841 = patch_info->data.gsharedvt;
  memcpy (D.27840, D.27841, 8);
  goto <D.25035>;
  <D.25039>:
  {
    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.27842 = monoeg_g_ptr_array_new ();
    info->entries = D.27842;
    D.27843 = oinfo->entries;
    if (D.27843 != 0B) goto <D.27844>; else goto <D.27845>;
    <D.27844>:
    i = 0;
    goto <D.25046>;
    <D.25045>:
    {
      struct MonoRuntimeGenericContextInfoTemplate * otemplate;
      struct MonoRuntimeGenericContextInfoTemplate * template;

      D.27843 = oinfo->entries;
      D.27846 = D.27843->pdata;
      i.86 = (unsigned int) i;
      D.27848 = i.86 * 4;
      D.27849 = D.27846 + D.27848;
      otemplate = *D.27849;
      template = mono_mempool_alloc0 (mp, 12);
      memcpy (template, otemplate, 12);
      D.27850 = info->entries;
      monoeg_g_ptr_array_add (D.27850, template);
    }
    i = i + 1;
    <D.25046>:
    i.87 = (unsigned int) i;
    D.27843 = oinfo->entries;
    D.27852 = D.27843->len;
    if (i.87 < D.27852) goto <D.25045>; else goto <D.25047>;
    <D.25047>:
    <D.27845>:
    goto <D.25035>;
  }
  <D.25048>:
  goto <D.25035>;
  <D.25035>:
  D.27853 = res;
  return D.27853;
}


mono_patch_info_hash (const void * data)
{
  <unnamed type> D.27856;
  guint D.27857;
  unsigned int D.27858;
  struct MonoJumpInfoToken * D.27859;
  unsigned int D.27860;
  unsigned int D.27861;
  unsigned int iftmp.88;
  int D.27863;
  struct MonoGenericInst * D.27866;
  const char * D.27868;
  unsigned int D.27869;
  const void * D.27870;
  unsigned int D.27871;
  struct MonoJumpInfoGSharedVtCall * D.27872;
  struct MonoMethod * D.27873;
  unsigned int D.27874;
  struct MonoMethod * D.27875;
  unsigned int D.27876;
  unsigned int D.27877;
  int D.27878;
  unsigned int D.27879;
  unsigned int D.27880;
  <unnamed type> D.27881;
  unsigned int D.27882;
  struct MonoJumpInfo * D.27883;
  unsigned int D.27884;
  struct MonoJumpInfoBBTable * D.27885;
  int D.27886;
  unsigned int D.27887;
  struct MonoGSharedVtMethodInfo * D.27888;
  struct MonoMethod * D.27889;
  unsigned int D.27890;
  const struct MonoJumpInfo * ji;

  ji = data;
  D.27856 = ji->type;
  switch (D.27856) <default: <D.25093>, case 3: <D.25066>, case 4: <D.25067>, case 6: <D.25065>, case 7: <D.25058>, case 8: <D.25090>, case 11: <D.25060>, case 12: <D.25068>, case 13: <D.25071>, case 14: <D.25059>, case 15: <D.25063>, case 16: <D.25072>, case 17: <D.25054>, case 18: <D.25055>, case 19: <D.25057>, case 23: <D.25061>, case 24: <D.25062>, case 27: <D.25089>, case 28: <D.25056>, case 29: <D.25053>, case 30: <D.25075>, case 31: <D.25070>, case 32: <D.25069>, case 33: <D.25082>, case 34: <D.25074>, case 35: <D.25080>, case 36: <D.25064>, case 37: <D.25086>, case 38: <D.25087>, case 39: <D.25083>, case 40: <D.25073>, case 42: <D.25084>, case 43: <D.25088>, case 44: <D.25076>, case 45: <D.25079>, case 46: <D.25091>, case 47: <D.25085>, case 48: <D.25077>, case 49: <D.25092>, case 50: <D.25078>>
  <D.25053>:
  <D.25054>:
  <D.25055>:
  <D.25056>:
  D.27856 = ji->type;
  D.27858 = D.27856 << 8;
  D.27859 = ji->data.token;
  D.27860 = D.27859->token;
  D.27857 = D.27858 | D.27860;
  return D.27857;
  <D.25057>:
  D.27856 = ji->type;
  D.27858 = D.27856 << 8;
  D.27859 = ji->data.token;
  D.27860 = D.27859->token;
  D.27861 = D.27858 | D.27860;
  D.27859 = ji->data.token;
  D.27863 = D.27859->has_context;
  if (D.27863 != 0) goto <D.27864>; else goto <D.27865>;
  <D.27864>:
  D.27859 = ji->data.token;
  D.27866 = D.27859->context.class_inst;
  iftmp.88 = (unsigned int) D.27866;
  goto <D.27867>;
  <D.27865>:
  iftmp.88 = 0;
  <D.27867>:
  D.27857 = D.27861 | iftmp.88;
  return D.27857;
  <D.25058>:
  D.27856 = ji->type;
  D.27858 = D.27856 << 8;
  D.27868 = ji->data.name;
  D.27869 = monoeg_g_str_hash (D.27868);
  D.27857 = D.27858 | D.27869;
  return D.27857;
  <D.25059>:
  <D.25060>:
  <D.25061>:
  <D.25062>:
  <D.25063>:
  <D.25064>:
  <D.25065>:
  <D.25066>:
  <D.25067>:
  <D.25068>:
  <D.25069>:
  <D.25070>:
  <D.25071>:
  <D.25072>:
  <D.25073>:
  <D.25074>:
  <D.25075>:
  <D.25076>:
  <D.25077>:
  <D.25078>:
  D.27856 = ji->type;
  D.27858 = D.27856 << 8;
  D.27870 = ji->data.target;
  D.27871 = (unsigned int) D.27870;
  D.27857 = D.27858 | D.27871;
  return D.27857;
  <D.25079>:
  D.27856 = ji->type;
  D.27858 = D.27856 << 8;
  D.27872 = ji->data.gsharedvt;
  D.27873 = D.27872->method;
  D.27874 = (unsigned int) D.27873;
  D.27857 = D.27858 | D.27874;
  return D.27857;
  <D.25080>:
  {
    struct MonoJumpInfoRgctxEntry * e;

    e = ji->data.rgctx_entry;
    D.27856 = ji->type;
    D.27858 = D.27856 << 8;
    D.27875 = e->method;
    D.27876 = (unsigned int) D.27875;
    D.27877 = D.27858 | D.27876;
    D.27878 = e->in_mrgctx;
    D.27879 = (unsigned int) D.27878;
    D.27880 = D.27877 | D.27879;
    D.27881 = e->info_type;
    D.27882 = D.27880 | D.27881;
    D.27883 = e->data;
    D.27884 = mono_patch_info_hash (D.27883);
    D.27857 = D.27882 | D.27884;
    return D.27857;
  }
  <D.25082>:
  <D.25083>:
  <D.25084>:
  <D.25085>:
  <D.25086>:
  <D.25087>:
  <D.25088>:
  <D.25089>:
  D.27856 = ji->type;
  D.27857 = D.27856 << 8;
  return D.27857;
  <D.25090>:
  D.27856 = ji->type;
  D.27858 = D.27856 << 8;
  D.27885 = ji->data.table;
  D.27886 = D.27885->table_size;
  D.27887 = (unsigned int) D.27886;
  D.27857 = D.27858 | D.27887;
  return D.27857;
  <D.25091>:
  D.27856 = ji->type;
  D.27858 = D.27856 << 8;
  D.27888 = ji->data.gsharedvt_method;
  D.27889 = D.27888->method;
  D.27890 = (unsigned int) D.27889;
  D.27857 = D.27858 | D.27890;
  return D.27857;
  <D.25092>:
  D.27870 = ji->data.target;
  D.27857 = monoeg_g_str_hash (D.27870);
  return D.27857;
  <D.25093>:
  D.27856 = ji->type;
  printf ("info type: %d\n", D.27856);
  mono_print_ji (ji);
  printf ("\n");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3203);
  D.27857 = 0;
  return D.27857;
}


mono_patch_info_equal (const void * ka, const void * kb)
{
  <unnamed type> D.27892;
  <unnamed type> D.27893;
  gint D.27896;
  struct MonoJumpInfoToken * D.27899;
  struct MonoImage * D.27900;
  struct MonoJumpInfoToken * D.27901;
  struct MonoImage * D.27902;
  unsigned int D.27904;
  unsigned int D.27905;
  int D.27907;
  int D.27908;
  struct MonoGenericInst * D.27910;
  struct MonoGenericInst * D.27911;
  struct MonoGenericInst * D.27913;
  struct MonoGenericInst * D.27914;
  const char * D.27915;
  const char * D.27916;
  int iftmp.89;
  struct MonoMethod * D.27920;
  struct MonoMethod * D.27921;
  int D.27923;
  int D.27924;
  <unnamed type> D.27926;
  <unnamed type> D.27927;
  struct MonoJumpInfo * D.27929;
  struct MonoJumpInfo * D.27930;
  int D.27931;
  int iftmp.90;
  struct MonoMethodSignature * D.27936;
  struct MonoMethodSignature * D.27937;
  struct MonoMethod * D.27939;
  struct MonoMethod * D.27940;
  struct MonoGSharedVtMethodInfo * D.27942;
  struct MonoMethod * D.27943;
  struct MonoGSharedVtMethodInfo * D.27944;
  struct MonoMethod * D.27945;
  _Bool D.27946;
  const void * D.27947;
  const void * D.27948;
  const struct MonoJumpInfo * ji1;
  const struct MonoJumpInfo * ji2;

  ji1 = ka;
  ji2 = kb;
  D.27892 = ji1->type;
  D.27893 = ji2->type;
  if (D.27892 != D.27893) goto <D.27894>; else goto <D.27895>;
  <D.27894>:
  D.27896 = 0;
  return D.27896;
  <D.27895>:
  D.27892 = ji1->type;
  switch (D.27892) <default: <D.25114>, case 7: <D.25106>, case 17: <D.25101>, case 18: <D.25103>, case 19: <D.25102>, case 28: <D.25104>, case 29: <D.25100>, case 35: <D.25107>, case 45: <D.25110>, case 46: <D.25113>>
  <D.25100>:
  <D.25101>:
  <D.25102>:
  <D.25103>:
  <D.25104>:
  D.27899 = ji1->data.token;
  D.27900 = D.27899->image;
  D.27901 = ji2->data.token;
  D.27902 = D.27901->image;
  if (D.27900 != D.27902) goto <D.27897>; else goto <D.27903>;
  <D.27903>:
  D.27899 = ji1->data.token;
  D.27904 = D.27899->token;
  D.27901 = ji2->data.token;
  D.27905 = D.27901->token;
  if (D.27904 != D.27905) goto <D.27897>; else goto <D.27906>;
  <D.27906>:
  D.27899 = ji1->data.token;
  D.27907 = D.27899->has_context;
  D.27901 = ji2->data.token;
  D.27908 = D.27901->has_context;
  if (D.27907 != D.27908) goto <D.27897>; else goto <D.27909>;
  <D.27909>:
  D.27899 = ji1->data.token;
  D.27910 = D.27899->context.class_inst;
  D.27901 = ji2->data.token;
  D.27911 = D.27901->context.class_inst;
  if (D.27910 != D.27911) goto <D.27897>; else goto <D.27912>;
  <D.27912>:
  D.27899 = ji1->data.token;
  D.27913 = D.27899->context.method_inst;
  D.27901 = ji2->data.token;
  D.27914 = D.27901->context.method_inst;
  if (D.27913 != D.27914) goto <D.27897>; else goto <D.27898>;
  <D.27897>:
  D.27896 = 0;
  return D.27896;
  <D.27898>:
  goto <D.25105>;
  <D.25106>:
  D.27915 = ji1->data.name;
  D.27916 = ji2->data.name;
  D.27896 = monoeg_g_str_equal (D.27915, D.27916);
  return D.27896;
  <D.25107>:
  {
    struct MonoJumpInfoRgctxEntry * e1;
    struct MonoJumpInfoRgctxEntry * e2;

    e1 = ji1->data.rgctx_entry;
    e2 = ji2->data.rgctx_entry;
    D.27920 = e1->method;
    D.27921 = e2->method;
    if (D.27920 == D.27921) goto <D.27922>; else goto <D.27918>;
    <D.27922>:
    D.27923 = e1->in_mrgctx;
    D.27924 = e2->in_mrgctx;
    if (D.27923 == D.27924) goto <D.27925>; else goto <D.27918>;
    <D.27925>:
    D.27926 = e1->info_type;
    D.27927 = e2->info_type;
    if (D.27926 == D.27927) goto <D.27928>; else goto <D.27918>;
    <D.27928>:
    D.27929 = e1->data;
    D.27930 = e2->data;
    D.27931 = mono_patch_info_equal (D.27929, D.27930);
    if (D.27931 != 0) goto <D.27932>; else goto <D.27918>;
    <D.27932>:
    iftmp.89 = 1;
    goto <D.27919>;
    <D.27918>:
    iftmp.89 = 0;
    <D.27919>:
    D.27896 = iftmp.89;
    return D.27896;
  }
  <D.25110>:
  {
    struct MonoJumpInfoGSharedVtCall * c1;
    struct MonoJumpInfoGSharedVtCall * c2;

    c1 = ji1->data.gsharedvt;
    c2 = ji2->data.gsharedvt;
    D.27936 = c1->sig;
    D.27937 = c2->sig;
    if (D.27936 == D.27937) goto <D.27938>; else goto <D.27934>;
    <D.27938>:
    D.27939 = c1->method;
    D.27940 = c2->method;
    if (D.27939 == D.27940) goto <D.27941>; else goto <D.27934>;
    <D.27941>:
    iftmp.90 = 1;
    goto <D.27935>;
    <D.27934>:
    iftmp.90 = 0;
    <D.27935>:
    D.27896 = iftmp.90;
    return D.27896;
  }
  <D.25113>:
  D.27942 = ji1->data.gsharedvt_method;
  D.27943 = D.27942->method;
  D.27944 = ji2->data.gsharedvt_method;
  D.27945 = D.27944->method;
  D.27946 = D.27943 == D.27945;
  D.27896 = (gint) D.27946;
  return D.27896;
  <D.25114>:
  D.27947 = ji1->data.target;
  D.27948 = ji2->data.target;
  if (D.27947 != D.27948) goto <D.27949>; else goto <D.27950>;
  <D.27949>:
  D.27896 = 0;
  return D.27896;
  <D.27950>:
  goto <D.25105>;
  <D.25105>:
  D.27896 = 1;
  return D.27896;
}


mono_resolve_patch_target (struct MonoMethod * method, struct MonoDomain * domain, guint8 * code, struct MonoJumpInfo * patch_info, gboolean run_cctors)
{
  int D.27952;
  sizetype D.27953;
  <unnamed type> D.27954;
  struct MonoBasicBlock * D.27955;
  int D.27956;
  sizetype D.27957;
  struct MonoInst * D.27958;
  int D.27959;
  sizetype D.27960;
  int D.27961;
  sizetype D.27962;
  const char * D.27963;
  struct MonoMethod * D.27968;
  union mono_mutex_t * D.27972;
  _Bool D.27975;
  long int D.27976;
  long int D.27977;
  void * D.27980;
  struct GHashTable * D.27981;
  struct GHashTable * D.27984;
  _Bool D.27989;
  long int D.27990;
  long int D.27991;
  unsigned int D.27997;
  unsigned int D.27998;
  struct MonoJitDynamicMethodInfo * D.28000;
  struct MonoCodeManager * D.28001;
  struct MonoJumpInfoBBTable * D.28002;
  int D.28003;
  unsigned int D.28004;
  unsigned int D.28005;
  int D.28006;
  int mono_aot_only.91;
  unsigned int i.92;
  unsigned int D.28012;
  void * * D.28013;
  struct MonoBasicBlock * * D.28014;
  struct MonoBasicBlock * * D.28015;
  struct MonoBasicBlock * D.28016;
  sizetype D.28017;
  void * D.28018;
  struct MonoClass * D.28019;
  short unsigned int D.28020;
  int D.28021;
  int D.28022;
  int D.28023;
  _Bool D.28024;
  long int D.28025;
  long int D.28026;
  _Bool D.28029;
  long int D.28030;
  long int D.28031;
  struct MonoClassField * D.28034;
  struct MonoClass * D.28035;
  int D.28036;
  _Bool D.28041;
  long int D.28042;
  long int D.28043;
  struct GHashTable * D.28046;
  _Bool D.28051;
  long int D.28052;
  long int D.28053;
  _Bool D.28056;
  long int D.28057;
  long int D.28058;
  void * D.28061;
  _Bool D.28062;
  long int D.28063;
  long int D.28064;
  unsigned int D.28069;
  unsigned int D.28070;
  struct MonoClass * D.28072;
  unsigned int D.28073;
  unsigned int D.28074;
  int D.28077;
  void * D.28081;
  int D.28082;
  sizetype D.28083;
  struct MonoJumpInfoToken * D.28084;
  unsigned int D.28085;
  struct MonoImage * D.28086;
  unsigned int D.28087;
  unsigned int rva.93;
  unsigned int D.28089;
  struct MonoGenericContext * iftmp.94;
  int D.28091;
  struct MonoClass * handle_class.95;
  struct MonoClass * D.28096;
  struct MonoGenericContext * iftmp.96;
  struct MonoClass * handle_class.97;
  const char * D.28102;
  short unsigned int D.28103;
  int D.28104;
  int D.28105;
  struct MonoImage * D.28114;
  const char * exc_class.98;
  const char * exc_arg.99;
  struct MonoException * D.28117;
  char * D.28118;
  char * D.28125;
  struct MonoClass * D.28126;
  _Bool D.28127;
  long int D.28128;
  long int D.28129;
  struct MonoGenericContext * D.28132;
  struct MonoGenericInst * D.28133;
  struct MonoJumpInfo * D.28134;
  <unnamed type> D.28135;
  struct MonoMethod * D.28136;
  int D.28137;
  struct MonoClass * D.28138;
  struct MonoType * D.28139;
  <unnamed type> D.28140;
  struct MonoGenericContext * D.28141;
  struct MonoMethod * D.28142;
  struct MonoGenericContext * D.28143;
  struct MonoClassField * D.28144;
  struct MonoGenericContext * D.28145;
  struct MonoMethodSignature * D.28146;
  struct MonoGenericContext * D.28147;
  struct MonoJumpInfoGSharedVtCall * D.28148;
  struct MonoGenericContext * D.28149;
  struct MonoMethod * D.28150;
  struct GPtrArray * D.28151;
  struct GPtrArray * D.28152;
  void * * D.28153;
  unsigned int i.100;
  unsigned int D.28155;
  void * * D.28156;
  struct GPtrArray * D.28157;
  unsigned int i.101;
  unsigned int D.28159;
  struct MonoGenericContext * D.28160;
  unsigned int mono_jit_tls_id.102;
  const void * D.28165;
  <unnamed type> D.28166;
  unsigned char * ip;
  const void * target;

  D.27952 = patch_info->ip.i;
  D.27953 = (sizetype) D.27952;
  ip = code + D.27953;
  target = 0B;
  D.27954 = patch_info->type;
  switch (D.27954) <default: <D.25222>, case 0: <D.25124>, case 1: <D.25126>, case 2: <D.25127>, case 3: <D.25135>, case 4: <D.25134>, case 5: <D.25129>, case 6: <D.25146>, case 7: <D.25130>, case 8: <D.25140>, case 10: <D.25167>, case 11: <D.25147>, case 12: <D.25148>, case 13: <D.25149>, case 14: <D.25153>, case 15: <D.25154>, case 16: <D.25157>, case 17: <D.25168>, case 18: <D.25172>, case 19: <D.25169>, case 20: <D.25165>, case 21: <D.25166>, case 22: <D.25128>, case 23: <D.25151>, case 24: <D.25152>, case 25: <D.25184>, case 26: <D.25185>, case 27: <D.25186>, case 28: <D.25175>, case 29: <D.25162>, case 30: <D.25156>, case 31: <D.25176>, case 32: <D.25132>, case 33: <D.25181>, case 34: <D.25182>, case 35: <D.25188>, case 36: <D.25209>, case 37: <D.25210>, case 38: <D.25211>, case 40: <D.25212>, case 41: <D.25213>, case 42: <D.25214>, case 43: <D.25217>, case 44: <D.25150>, case 47: <D.25218>, case 48: <D.25219>, case 49: <D.25221>, case 50: <D.25136>, case 51: <D.25187>>
  <D.25124>:
  D.27955 = patch_info->data.bb;
  D.27956 = D.27955->native_offset;
  D.27957 = (sizetype) D.27956;
  target = code + D.27957;
  goto <D.25125>;
  <D.25126>:
  target = patch_info->data.target;
  goto <D.25125>;
  <D.25127>:
  D.27958 = patch_info->data.inst;
  D.27959 = D.27958->data.op[0].const_val;
  D.27960 = (sizetype) D.27959;
  target = code + D.27960;
  goto <D.25125>;
  <D.25128>:
  target = ip;
  goto <D.25125>;
  <D.25129>:
  D.27961 = patch_info->data.offset;
  D.27962 = (sizetype) D.27961;
  target = code + D.27962;
  goto <D.25125>;
  <D.25130>:
  {
    struct MonoJitICallInfo * mi;

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

    D.27963 = patch_info->data.name;
    mi = mono_find_jit_icall_by_name (D.27963);
    if (mi == 0B) goto <D.27966>; else goto <D.27967>;
    <D.27966>:
    D.27963 = patch_info->data.name;
    monoeg_g_log (0B, 16, "unknown MONO_PATCH_INFO_JIT_ICALL_ADDR %s", D.27963);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3308);
    <D.27967>:
    target = mi->func;
    goto <D.25125>;
  }
  <D.25134>:
  D.27968 = patch_info->data.method;
  target = mono_create_jump_trampoline (domain, D.27968, 0);
  goto <D.25125>;
  <D.25135>:
  D.27968 = patch_info->data.method;
  if (D.27968 == method) goto <D.27969>; else goto <D.27970>;
  <D.27969>:
  target = code;
  goto <D.27971>;
  <D.27970>:
  D.27968 = patch_info->data.method;
  target = mono_create_jit_trampoline_in_domain (domain, D.27968);
  <D.27971>:
  goto <D.25125>;
  <D.25136>:
  {
    void * code_slot;

    {
      int ret;

      D.27972 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.27972);
      if (ret != 0) goto <D.27973>; else goto <D.27974>;
      <D.27973>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.27974>:
      D.27975 = ret != 0;
      D.27976 = (long int) D.27975;
      D.27977 = __builtin_expect (D.27976, 0);
      if (D.27977 != 0) goto <D.27978>; else goto <D.27979>;
      <D.27978>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3343, "ret == 0");
      <D.27979>:
    }
    D.27980 = domain->runtime_info;
    D.27981 = MEM[(struct MonoJitDomainInfo *)D.27980].method_code_hash;
    if (D.27981 == 0B) goto <D.27982>; else goto <D.27983>;
    <D.27982>:
    D.27980 = domain->runtime_info;
    D.27984 = monoeg_g_hash_table_new (0B, 0B);
    MEM[(struct MonoJitDomainInfo *)D.27980].method_code_hash = D.27984;
    <D.27983>:
    D.27980 = domain->runtime_info;
    D.27981 = MEM[(struct MonoJitDomainInfo *)D.27980].method_code_hash;
    D.27968 = patch_info->data.method;
    code_slot = monoeg_g_hash_table_lookup (D.27981, D.27968);
    if (code_slot == 0B) goto <D.27985>; else goto <D.27986>;
    <D.27985>:
    code_slot = mono_domain_alloc0 (domain, 4);
    D.27980 = domain->runtime_info;
    D.27981 = MEM[(struct MonoJitDomainInfo *)D.27980].method_code_hash;
    D.27968 = patch_info->data.method;
    monoeg_g_hash_table_insert_replace (D.27981, D.27968, code_slot, 0);
    <D.27986>:
    {
      int ret;

      D.27972 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.27972);
      if (ret != 0) goto <D.27987>; else goto <D.27988>;
      <D.27987>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.27988>:
      D.27989 = ret != 0;
      D.27990 = (long int) D.27989;
      D.27991 = __builtin_expect (D.27990, 0);
      if (D.27991 != 0) goto <D.27992>; else goto <D.27993>;
      <D.27992>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3351, "ret == 0");
      <D.27993>:
    }
    target = code_slot;
    goto <D.25125>;
  }
  <D.25140>:
  {
    void * * jump_table;
    int i;

    if (method != 0B) goto <D.27996>; else goto <D.27994>;
    <D.27996>:
    D.27997 = BIT_FIELD_REF <*method, 32, 160>;
    D.27998 = D.27997 & 512;
    if (D.27998 != 0) goto <D.27999>; else goto <D.27994>;
    <D.27999>:
    D.28000 = mono_dynamic_code_hash_lookup (domain, method);
    D.28001 = D.28000->code_mp;
    D.28002 = patch_info->data.table;
    D.28003 = D.28002->table_size;
    D.28004 = (unsigned int) D.28003;
    D.28005 = D.28004 * 4;
    D.28006 = (int) D.28005;
    jump_table = mono_code_manager_reserve (D.28001, D.28006);
    goto <D.27995>;
    <D.27994>:
    mono_aot_only.91 = mono_aot_only;
    if (mono_aot_only.91 != 0) goto <D.28008>; else goto <D.28009>;
    <D.28008>:
    D.28002 = patch_info->data.table;
    D.28003 = D.28002->table_size;
    D.28004 = (unsigned int) D.28003;
    D.28005 = D.28004 * 4;
    jump_table = mono_domain_alloc (domain, D.28005);
    goto <D.28010>;
    <D.28009>:
    D.28002 = patch_info->data.table;
    D.28003 = D.28002->table_size;
    D.28004 = (unsigned int) D.28003;
    D.28005 = D.28004 * 4;
    D.28006 = (int) D.28005;
    jump_table = mono_domain_code_reserve (domain, D.28006);
    <D.28010>:
    <D.27995>:
    i = 0;
    goto <D.25144>;
    <D.25143>:
    i.92 = (unsigned int) i;
    D.28012 = i.92 * 4;
    D.28013 = jump_table + D.28012;
    D.28002 = patch_info->data.table;
    D.28014 = D.28002->table;
    i.92 = (unsigned int) i;
    D.28012 = i.92 * 4;
    D.28015 = D.28014 + D.28012;
    D.28016 = *D.28015;
    D.28017 = (sizetype) D.28016;
    D.28018 = code + D.28017;
    *D.28013 = D.28018;
    i = i + 1;
    <D.25144>:
    D.28002 = patch_info->data.table;
    D.28003 = D.28002->table_size;
    if (D.28003 > i) goto <D.25143>; else goto <D.25145>;
    <D.25145>:
    target = jump_table;
    goto <D.25125>;
  }
  <D.25146>:
  <D.25147>:
  <D.25148>:
  <D.25149>:
  <D.25150>:
  target = patch_info->data.target;
  goto <D.25125>;
  <D.25151>:
  D.28019 = patch_info->data.klass;
  mono_class_init (D.28019);
  D.28019 = patch_info->data.klass;
  D.28020 = D.28019->interface_id;
  D.28021 = (int) D.28020;
  target = (const void *) D.28021;
  goto <D.25125>;
  <D.25152>:
  D.28019 = patch_info->data.klass;
  mono_class_init (D.28019);
  D.28019 = patch_info->data.klass;
  D.28020 = D.28019->interface_id;
  D.28021 = (int) D.28020;
  D.28022 = ~D.28021;
  D.28023 = D.28022 * 4;
  target = (const void *) D.28023;
  goto <D.25125>;
  <D.25153>:
  D.28019 = patch_info->data.klass;
  target = mono_class_vtable (domain, D.28019);
  D.28024 = target == 0B;
  D.28025 = (long int) D.28024;
  D.28026 = __builtin_expect (D.28025, 0);
  if (D.28026 != 0) goto <D.28027>; else goto <D.28028>;
  <D.28027>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3412, "target");
  <D.28028>:
  goto <D.25125>;
  <D.25154>:
  {
    struct MonoVTable * vtable;

    D.28019 = patch_info->data.klass;
    vtable = mono_class_vtable (domain, D.28019);
    D.28029 = vtable == 0B;
    D.28030 = (long int) D.28029;
    D.28031 = __builtin_expect (D.28030, 0);
    if (D.28031 != 0) goto <D.28032>; else goto <D.28033>;
    <D.28032>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3417, "vtable");
    <D.28033>:
    target = mono_create_class_init_trampoline (vtable);
    goto <D.25125>;
  }
  <D.25156>:
  D.28019 = patch_info->data.klass;
  target = mono_create_delegate_trampoline (domain, D.28019);
  goto <D.25125>;
  <D.25157>:
  {
    struct MonoVTable * vtable;

    D.28034 = patch_info->data.field;
    D.28035 = D.28034->parent;
    vtable = mono_class_vtable (domain, D.28035);
    D.28034 = patch_info->data.field;
    D.28036 = mono_class_field_is_special_static (D.28034);
    if (D.28036 != 0) goto <D.28037>; else goto <D.28038>;
    <D.28037>:
    {
      void * addr;

      addr = 0B;
      {
        int ret;

        D.27972 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.27972);
        if (ret != 0) goto <D.28039>; else goto <D.28040>;
        <D.28039>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28040>:
        D.28041 = ret != 0;
        D.28042 = (long int) D.28041;
        D.28043 = __builtin_expect (D.28042, 0);
        if (D.28043 != 0) goto <D.28044>; else goto <D.28045>;
        <D.28044>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3430, "ret == 0");
        <D.28045>:
      }
      D.28046 = domain->special_static_fields;
      if (D.28046 != 0B) goto <D.28047>; else goto <D.28048>;
      <D.28047>:
      D.28046 = domain->special_static_fields;
      D.28034 = patch_info->data.field;
      addr = monoeg_g_hash_table_lookup (D.28046, D.28034);
      <D.28048>:
      {
        int ret;

        D.27972 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.27972);
        if (ret != 0) goto <D.28049>; else goto <D.28050>;
        <D.28049>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28050>:
        D.28051 = ret != 0;
        D.28052 = (long int) D.28051;
        D.28053 = __builtin_expect (D.28052, 0);
        if (D.28053 != 0) goto <D.28054>; else goto <D.28055>;
        <D.28054>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3433, "ret == 0");
        <D.28055>:
      }
      D.28056 = addr == 0B;
      D.28057 = (long int) D.28056;
      D.28058 = __builtin_expect (D.28057, 0);
      if (D.28058 != 0) goto <D.28059>; else goto <D.28060>;
      <D.28059>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3434, "addr");
      <D.28060>:
      D.28061 = addr;
      return D.28061;
    }
    <D.28038>:
    D.28062 = vtable == 0B;
    D.28063 = (long int) D.28062;
    D.28064 = __builtin_expect (D.28063, 0);
    if (D.28064 != 0) goto <D.28065>; else goto <D.28066>;
    <D.28065>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3438, "vtable");
    <D.28066>:
    D.28069 = BIT_FIELD_REF <*vtable, 32, 160>;
    D.28070 = D.28069 & 33554432;
    if (D.28070 == 0) goto <D.28071>; else goto <D.28067>;
    <D.28071>:
    D.28072 = vtable->klass;
    D.28073 = D.28072->flags;
    D.28074 = D.28073 & 1048576;
    if (D.28074 == 0) goto <D.28075>; else goto <D.28067>;
    <D.28075>:
    if (method != 0B) goto <D.28076>; else goto <D.28067>;
    <D.28076>:
    D.28072 = vtable->klass;
    D.28077 = mono_class_needs_cctor_run (D.28072, method);
    if (D.28077 != 0) goto <D.28078>; else goto <D.28067>;
    <D.28078>:
    goto <D.28068>;
    <D.28067>:
    if (run_cctors != 0) goto <D.28079>; else goto <D.28080>;
    <D.28079>:
    mono_runtime_class_init (vtable);
    <D.28080>:
    <D.28068>:
    D.28081 = mono_vtable_get_static_field_data (vtable);
    D.28034 = patch_info->data.field;
    D.28082 = D.28034->offset;
    D.28083 = (sizetype) D.28082;
    target = D.28081 + D.28083;
    goto <D.25125>;
  }
  <D.25162>:
  {
    guint32 field_index;
    guint32 rva;

    try
      {
        D.28084 = patch_info->data.token;
        D.28085 = D.28084->token;
        field_index = D.28085 & 16777215;
        D.28084 = patch_info->data.token;
        D.28086 = D.28084->image;
        D.28087 = field_index + 4294967295;
        mono_metadata_field_info (D.28086, D.28087, 0B, &rva, 0B);
        D.28084 = patch_info->data.token;
        D.28086 = D.28084->image;
        rva.93 = rva;
        target = mono_image_rva_map (D.28086, rva.93);
        goto <D.25125>;
      }
    finally
      {
        rva = {CLOBBER};
      }
  }
  <D.25165>:
  <D.25166>:
  target = patch_info->data.target;
  goto <D.25125>;
  <D.25167>:
  target = patch_info->data.name;
  goto <D.25125>;
  <D.25168>:
  D.28084 = patch_info->data.token;
  D.28086 = D.28084->image;
  D.28084 = patch_info->data.token;
  D.28085 = D.28084->token;
  D.28089 = D.28085 & 16777215;
  target = mono_ldstr (domain, D.28086, D.28089);
  goto <D.25125>;
  <D.25169>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.28084 = patch_info->data.token;
        D.28086 = D.28084->image;
        D.28084 = patch_info->data.token;
        D.28085 = D.28084->token;
        D.28084 = patch_info->data.token;
        D.28091 = D.28084->has_context;
        if (D.28091 != 0) goto <D.28092>; else goto <D.28093>;
        <D.28092>:
        D.28084 = patch_info->data.token;
        iftmp.94 = &D.28084->context;
        goto <D.28094>;
        <D.28093>:
        iftmp.94 = 0B;
        <D.28094>:
        handle = mono_ldtoken (D.28086, D.28085, &handle_class, iftmp.94);
        handle_class.95 = handle_class;
        mono_class_init (handle_class.95);
        D.28096 = mono_class_from_mono_type (handle);
        mono_class_init (D.28096);
        target = mono_type_get_object (domain, handle);
        goto <D.25125>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.25172>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.28084 = patch_info->data.token;
        D.28086 = D.28084->image;
        D.28084 = patch_info->data.token;
        D.28085 = D.28084->token;
        D.28084 = patch_info->data.token;
        D.28091 = D.28084->has_context;
        if (D.28091 != 0) goto <D.28098>; else goto <D.28099>;
        <D.28098>:
        D.28084 = patch_info->data.token;
        iftmp.96 = &D.28084->context;
        goto <D.28100>;
        <D.28099>:
        iftmp.96 = 0B;
        <D.28100>:
        handle = mono_ldtoken (D.28086, D.28085, &handle_class, iftmp.96);
        handle_class.97 = handle_class;
        mono_class_init (handle_class.97);
        target = handle;
        goto <D.25125>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.25175>:
  D.28084 = patch_info->data.token;
  D.28086 = D.28084->image;
  D.28084 = patch_info->data.token;
  D.28085 = D.28084->token;
  D.28102 = mono_metadata_blob_heap (D.28086, D.28085);
  target = D.28102 + 2;
  goto <D.25125>;
  <D.25176>:
  D.27968 = patch_info->data.method;
  D.28103 = D.27968->flags;
  D.28104 = (int) D.28103;
  D.28105 = D.28104 & 8192;
  if (D.28105 != 0) goto <D.28106>; else goto <D.28107>;
  <D.28106>:
  {
    const char * exc_class;
    const char * exc_arg;

    try
      {
        if (run_cctors != 0) goto <D.28108>; else goto <D.28109>;
        <D.28108>:
        D.27968 = patch_info->data.method;
        target = mono_lookup_pinvoke_call (D.27968, &exc_class, &exc_arg);
        if (target == 0B) goto <D.28110>; else goto <D.28111>;
        <D.28110>:
        mono_aot_only.91 = mono_aot_only;
        if (mono_aot_only.91 != 0) goto <D.28112>; else goto <D.28113>;
        <D.28112>:
        D.28114 = mono_defaults.corlib;
        exc_class.98 = exc_class;
        exc_arg.99 = exc_arg;
        D.28117 = mono_exception_from_name_msg (D.28114, "System", exc_class.98, exc_arg.99);
        mono_raise_exception (D.28117);
        <D.28113>:
        D.27968 = patch_info->data.method;
        D.28118 = mono_method_full_name (D.27968, 1);
        monoeg_g_log (0B, 4, "Unable to resolve pinvoke method \'%s\' Re-run with MONO_LOG_LEVEL=debug for more information.\n", D.28118);
        <D.25179>:
        goto <D.25179>;
        <D.28111>:
        goto <D.28119>;
        <D.28109>:
        target = 0B;
        <D.28119>:
      }
    finally
      {
        exc_class = {CLOBBER};
        exc_arg = {CLOBBER};
      }
  }
  goto <D.28120>;
  <D.28107>:
  D.27968 = patch_info->data.method;
  target = mono_lookup_internal_call (D.27968);
  if (target == 0B) goto <D.28121>; else goto <D.28122>;
  <D.28121>:
  if (run_cctors != 0) goto <D.28123>; else goto <D.28124>;
  <D.28123>:
  D.27968 = patch_info->data.method;
  D.28125 = mono_method_full_name (D.27968, 1);
  monoeg_g_log (0B, 4, "Unregistered icall \'%s\'\n", D.28125);
  <D.25180>:
  goto <D.25180>;
  <D.28124>:
  <D.28122>:
  <D.28120>:
  goto <D.25125>;
  <D.25181>:
  target = mono_thread_interruption_request_flag ();
  goto <D.25125>;
  <D.25182>:
  {
    struct MonoVTable * vtable;

    D.27968 = patch_info->data.method;
    D.28126 = D.27968->klass;
    vtable = mono_class_vtable (domain, D.28126);
    D.28127 = vtable == 0B;
    D.28128 = (long int) D.28127;
    D.28129 = __builtin_expect (D.28128, 0);
    if (D.28129 != 0) goto <D.28130>; else goto <D.28131>;
    <D.28130>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3524, "vtable");
    <D.28131>:
    D.27968 = patch_info->data.method;
    D.28132 = mini_method_get_context (D.27968);
    D.28133 = D.28132->method_inst;
    target = mono_method_lookup_rgctx (vtable, D.28133);
    goto <D.25125>;
  }
  <D.25184>:
  <D.25185>:
  <D.25186>:
  <D.25187>:
  goto <D.25125>;
  <D.25188>:
  {
    struct MonoJumpInfoRgctxEntry * entry;
    guint32 slot;

    entry = patch_info->data.rgctx_entry;
    slot = 4294967295;
    D.28134 = entry->data;
    D.28135 = D.28134->type;
    switch (D.28135) <default: <D.25208>, case 3: <D.25193>, case 6: <D.25194>, case 11: <D.25191>, case 13: <D.25195>, case 44: <D.25196>, case 45: <D.25197>, case 46: <D.25199>>
    <D.25191>:
    D.28136 = entry->method;
    D.28137 = entry->in_mrgctx;
    D.28134 = entry->data;
    D.28138 = D.28134->data.klass;
    D.28139 = &D.28138->byval_arg;
    D.28140 = entry->info_type;
    D.28136 = entry->method;
    D.28141 = mono_method_get_context (D.28136);
    slot = mono_method_lookup_or_register_info (D.28136, D.28137, D.28139, D.28140, D.28141);
    goto <D.25192>;
    <D.25193>:
    <D.25194>:
    D.28136 = entry->method;
    D.28137 = entry->in_mrgctx;
    D.28134 = entry->data;
    D.28142 = D.28134->data.method;
    D.28140 = entry->info_type;
    D.28136 = entry->method;
    D.28143 = mono_method_get_context (D.28136);
    slot = mono_method_lookup_or_register_info (D.28136, D.28137, D.28142, D.28140, D.28143);
    goto <D.25192>;
    <D.25195>:
    D.28136 = entry->method;
    D.28137 = entry->in_mrgctx;
    D.28134 = entry->data;
    D.28144 = D.28134->data.field;
    D.28140 = entry->info_type;
    D.28136 = entry->method;
    D.28145 = mono_method_get_context (D.28136);
    slot = mono_method_lookup_or_register_info (D.28136, D.28137, D.28144, D.28140, D.28145);
    goto <D.25192>;
    <D.25196>:
    D.28136 = entry->method;
    D.28137 = entry->in_mrgctx;
    D.28134 = entry->data;
    D.28146 = D.28134->data.sig;
    D.28140 = entry->info_type;
    D.28136 = entry->method;
    D.28147 = mono_method_get_context (D.28136);
    slot = mono_method_lookup_or_register_info (D.28136, D.28137, D.28146, D.28140, D.28147);
    goto <D.25192>;
    <D.25197>:
    {
      struct MonoJumpInfoGSharedVtCall * call_info;

      call_info = monoeg_malloc0 (8);
      D.28134 = entry->data;
      D.28148 = D.28134->data.gsharedvt;
      memcpy (call_info, D.28148, 8);
      D.28136 = entry->method;
      D.28137 = entry->in_mrgctx;
      D.28140 = entry->info_type;
      D.28136 = entry->method;
      D.28149 = mono_method_get_context (D.28136);
      slot = mono_method_lookup_or_register_info (D.28136, D.28137, call_info, D.28140, D.28149);
      goto <D.25192>;
    }
    <D.25199>:
    {
      struct MonoGSharedVtMethodInfo * info;
      struct MonoGSharedVtMethodInfo * oinfo;
      int i;

      D.28134 = entry->data;
      oinfo = D.28134->data.gsharedvt_method;
      info = monoeg_malloc0 (8);
      D.28150 = oinfo->method;
      info->method = D.28150;
      D.28151 = monoeg_g_ptr_array_new ();
      info->entries = D.28151;
      i = 0;
      goto <D.25206>;
      <D.25205>:
      {
        struct MonoRuntimeGenericContextInfoTemplate * otemplate;
        struct MonoRuntimeGenericContextInfoTemplate * template;

        D.28152 = oinfo->entries;
        D.28153 = D.28152->pdata;
        i.100 = (unsigned int) i;
        D.28155 = i.100 * 4;
        D.28156 = D.28153 + D.28155;
        otemplate = *D.28156;
        template = monoeg_malloc0 (12);
        memcpy (template, otemplate, 12);
        D.28157 = info->entries;
        monoeg_g_ptr_array_add (D.28157, template);
      }
      i = i + 1;
      <D.25206>:
      i.101 = (unsigned int) i;
      D.28152 = oinfo->entries;
      D.28159 = D.28152->len;
      if (i.101 < D.28159) goto <D.25205>; else goto <D.25207>;
      <D.25207>:
      D.28136 = entry->method;
      D.28137 = entry->in_mrgctx;
      D.28140 = entry->info_type;
      D.28136 = entry->method;
      D.28160 = mono_method_get_context (D.28136);
      slot = mono_method_lookup_or_register_info (D.28136, D.28137, info, D.28140, D.28160);
      goto <D.25192>;
    }
    <D.25208>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3579);
    <D.25192>:
    target = mono_create_rgctx_lazy_fetch_trampoline (slot);
    goto <D.25125>;
  }
  <D.25209>:
  target = mono_create_generic_class_init_trampoline ();
  goto <D.25125>;
  <D.25210>:
  target = mono_create_monitor_enter_trampoline ();
  goto <D.25125>;
  <D.25211>:
  target = mono_create_monitor_exit_trampoline ();
  goto <D.25125>;
  <D.25212>:
  if (run_cctors == 0) goto <D.28161>; else goto <D.28162>;
  <D.28161>:
  target = 0B;
  goto <D.28163>;
  <D.28162>:
  target = mono_arch_get_seq_point_info (domain, code);
  <D.28163>:
  goto <D.25125>;
  <D.25213>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3609);
  <D.25214>:
  {
    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.25125>;
      }
    finally
      {
        card_table_shift_bits = {CLOBBER};
        card_table_mask = {CLOBBER};
      }
  }
  <D.25217>:
  target = mono_domain_alloc0 (domain, 4);
  goto <D.25125>;
  <D.25218>:
  mono_jit_tls_id.102 = mono_jit_tls_id;
  target = (const void *) mono_jit_tls_id.102;
  goto <D.25125>;
  <D.25219>:
  {
    int offset;

    D.28165 = patch_info->data.target;
    D.28166 = (<unnamed type>) D.28165;
    offset = mini_get_tls_offset (D.28166);
    target = (const void *) offset;
    goto <D.25125>;
  }
  <D.25221>:
  target = 0B;
  goto <D.25125>;
  <D.25222>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3642);
  <D.25125>:
  D.28061 = target;
  return D.28061;
}


mono_dynamic_code_hash_lookup (struct MonoDomain * domain, struct MonoMethod * method)
{
  void * D.28173;
  struct GHashTable * D.28174;
  struct MonoJitDynamicMethodInfo * D.28178;
  struct MonoJitDynamicMethodInfo * res;

  D.28173 = domain->runtime_info;
  D.28174 = MEM[(struct MonoJitDomainInfo *)D.28173].dynamic_code_hash;
  if (D.28174 != 0B) goto <D.28175>; else goto <D.28176>;
  <D.28175>:
  D.28173 = domain->runtime_info;
  D.28174 = MEM[(struct MonoJitDomainInfo *)D.28173].dynamic_code_hash;
  res = monoeg_g_hash_table_lookup (D.28174, method);
  goto <D.28177>;
  <D.28176>:
  res = 0B;
  <D.28177>:
  D.28178 = res;
  return D.28178;
}


mono_add_seq_point (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, int native_offset)
{
  struct GPtrArray * D.28180;
  struct MonoMemPool * D.28183;
  struct GSList * D.28184;
  struct GSList * D.28185;

  ins->data.op[0].const_val = native_offset;
  D.28180 = cfg->seq_points;
  monoeg_g_ptr_array_add (D.28180, ins);
  if (bb != 0B) goto <D.28181>; else goto <D.28182>;
  <D.28181>:
  D.28183 = cfg->mempool;
  D.28184 = bb->seq_points;
  D.28185 = g_slist_prepend_mempool (D.28183, D.28184, ins);
  bb->seq_points = D.28185;
  bb->last_seq_point = ins;
  <D.28182>:
}


mono_add_var_location (struct MonoCompile * cfg, struct MonoInst * var, gboolean is_reg, int reg, int offset, int from, int to)
{
  struct MonoMemPool * D.28186;
  _Bool D.28189;
  long int D.28190;
  long int D.28191;
  struct MonoInst * * D.28194;
  struct MonoInst * D.28195;
  struct GSList * D.28198;
  struct GSList * D.28199;
  struct MonoInst * D.28201;
  struct GSList * D.28204;
  struct GSList * D.28205;
  struct MonoDwarfLocListEntry * entry;

  D.28186 = cfg->mempool;
  entry = mono_mempool_alloc0 (D.28186, 20);
  if (is_reg != 0) goto <D.28187>; else goto <D.28188>;
  <D.28187>:
  D.28189 = offset != 0;
  D.28190 = (long int) D.28189;
  D.28191 = __builtin_expect (D.28190, 0);
  if (D.28191 != 0) goto <D.28192>; else goto <D.28193>;
  <D.28192>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3665, "offset == 0");
  <D.28193>:
  <D.28188>:
  entry->is_reg = is_reg;
  entry->reg = reg;
  entry->offset = offset;
  entry->from = from;
  entry->to = to;
  D.28194 = cfg->args;
  D.28195 = *D.28194;
  if (D.28195 == var) goto <D.28196>; else goto <D.28197>;
  <D.28196>:
  D.28186 = cfg->mempool;
  D.28198 = cfg->this_loclist;
  D.28199 = g_slist_append_mempool (D.28186, D.28198, entry);
  cfg->this_loclist = D.28199;
  goto <D.28200>;
  <D.28197>:
  D.28201 = cfg->rgctx_var;
  if (D.28201 == var) goto <D.28202>; else goto <D.28203>;
  <D.28202>:
  D.28186 = cfg->mempool;
  D.28204 = cfg->rgctx_loclist;
  D.28205 = g_slist_append_mempool (D.28186, D.28204, entry);
  cfg->rgctx_loclist = D.28205;
  <D.28203>:
  <D.28200>:
}


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

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


mono_codegen (struct MonoCompile * cfg)
{
  int mono_using_xdebug.103;
  unsigned int D.28210;
  unsigned int D.28211;
  unsigned int D.28214;
  unsigned int D.28215;
  unsigned int D.28220;
  unsigned int D.28221;
  struct MonoMethod * D.28224;
  unsigned int D.28225;
  int D.28226;
  struct MonoProfileCoverageInfo * D.28227;
  unsigned int D.28228;
  int code.104;
  unsigned char * D.28232;
  int D.28233;
  int D.28234;
  unsigned int D.28235;
  unsigned int D.28236;
  int D.28237;
  int D.28238;
  unsigned int D.28239;
  unsigned int D.28240;
  int D.28241;
  struct MonoBasicBlock * D.28242;
  unsigned int D.28247;
  _Bool D.28248;
  long int D.28249;
  long int D.28250;
  unsigned int max_epilog_size.105;
  unsigned int D.28254;
  unsigned int D.28255;
  unsigned int D.28256;
  void * D.28259;
  struct MonoJitDynamicMethodInfo * D.28260;
  struct MonoCodeManager * D.28261;
  struct MonoDomain * D.28262;
  union mono_mutex_t * D.28263;
  _Bool D.28266;
  long int D.28267;
  long int D.28268;
  _Bool D.28273;
  long int D.28274;
  long int D.28275;
  unsigned int D.28280;
  int D.28281;
  struct MonoCodeManager * D.28283;
  unsigned int D.28285;
  int D.28286;
  _Bool D.28287;
  long int D.28288;
  long int D.28289;
  unsigned int D.28292;
  unsigned char * D.28295;
  char * D.28296;
  unsigned int D.28299;
  struct MonoGenericContainer * D.28301;
  struct MonoClass * D.28303;
  struct MonoGenericContainer * D.28304;
  struct MonoGenericClass * D.28306;
  struct MonoGenericSharingContext * D.28307;
  _Bool D.28310;
  long int D.28311;
  long int D.28312;
  struct MonoJumpInfo * D.28315;
  struct MonoCodeManager * iftmp.106;
  <unnamed-unsigned:1> D.28320;
  int D.28321;
  int D.28326;
  int D.28329;
  struct MonoBasicBlock * bb;
  int max_epilog_size;
  guint8 * code;
  struct MonoDomain * code_domain;

  mono_using_xdebug.103 = mono_using_xdebug;
  if (mono_using_xdebug.103 != 0) goto <D.28207>; else goto <D.28208>;
  <D.28207>:
  code_domain = mono_get_root_domain ();
  goto <D.28209>;
  <D.28208>:
  code_domain = cfg->domain;
  <D.28209>:
  bb = cfg->bb_entry;
  goto <D.25358>;
  <D.25357>:
  cfg->spill_count = 0;
  mono_arch_lowering_pass (cfg, bb);
  D.28210 = cfg->opt;
  D.28211 = D.28210 & 1;
  if (D.28211 != 0) goto <D.28212>; else goto <D.28213>;
  <D.28212>:
  mono_arch_peephole_pass_1 (cfg, bb);
  <D.28213>:
  D.28214 = BIT_FIELD_REF <*cfg, 32, 3392>;
  D.28215 = D.28214 & 4096;
  if (D.28215 == 0) goto <D.28216>; else goto <D.28217>;
  <D.28216>:
  mono_local_regalloc (cfg, bb);
  <D.28217>:
  D.28210 = cfg->opt;
  D.28211 = D.28210 & 1;
  if (D.28211 != 0) goto <D.28218>; else goto <D.28219>;
  <D.28218>:
  mono_arch_peephole_pass_2 (cfg, bb);
  <D.28219>:
  bb = bb->next_bb;
  <D.25358>:
  if (bb != 0B) goto <D.25357>; else goto <D.25359>;
  <D.25359>:
  D.28220 = cfg->prof_options;
  D.28221 = D.28220 & 8192;
  if (D.28221 != 0) goto <D.28222>; else goto <D.28223>;
  <D.28222>:
  D.28224 = cfg->method;
  D.28225 = cfg->num_bblocks;
  D.28226 = (int) D.28225;
  D.28227 = mono_profiler_coverage_alloc (D.28224, D.28226);
  cfg->coverage_info = D.28227;
  <D.28223>:
  code = mono_arch_emit_prolog (cfg);
  D.28220 = cfg->prof_options;
  D.28228 = D.28220 & 4096;
  if (D.28228 != 0) goto <D.28229>; else goto <D.28230>;
  <D.28229>:
  code = mono_arch_instrument_prolog (cfg, mono_profiler_method_enter, code, 0);
  <D.28230>:
  code.104 = (int) code;
  D.28232 = cfg->native_code;
  D.28233 = (int) D.28232;
  D.28234 = code.104 - D.28233;
  D.28235 = (unsigned int) D.28234;
  cfg->code_len = D.28235;
  D.28236 = cfg->code_len;
  cfg->prolog_end = D.28236;
  mono_debug_open_method (cfg);
  bb = cfg->bb_entry;
  goto <D.25361>;
  <D.25360>:
  D.28236 = cfg->code_len;
  D.28237 = (int) D.28236;
  bb->native_offset = D.28237;
  D.28236 = cfg->code_len;
  D.28237 = (int) D.28236;
  bb->real_native_offset = D.28237;
  mono_arch_output_basic_block (cfg, bb);
  D.28236 = cfg->code_len;
  D.28238 = bb->native_offset;
  D.28239 = (unsigned int) D.28238;
  D.28240 = D.28236 - D.28239;
  D.28241 = (int) D.28240;
  bb->native_length = D.28241;
  D.28242 = cfg->bb_exit;
  if (D.28242 == bb) goto <D.28243>; else goto <D.28244>;
  <D.28243>:
  D.28236 = cfg->code_len;
  cfg->epilog_begin = D.28236;
  D.28220 = cfg->prof_options;
  D.28228 = D.28220 & 4096;
  if (D.28228 != 0) goto <D.28245>; else goto <D.28246>;
  <D.28245>:
  D.28232 = cfg->native_code;
  D.28236 = cfg->code_len;
  code = D.28232 + D.28236;
  code = mono_arch_instrument_epilog (cfg, mono_profiler_method_leave, code, 0);
  code.104 = (int) code;
  D.28232 = cfg->native_code;
  D.28233 = (int) D.28232;
  D.28234 = code.104 - D.28233;
  D.28235 = (unsigned int) D.28234;
  cfg->code_len = D.28235;
  D.28236 = cfg->code_len;
  D.28247 = cfg->code_size;
  D.28248 = D.28236 >= D.28247;
  D.28249 = (long int) D.28248;
  D.28250 = __builtin_expect (D.28249, 0);
  if (D.28250 != 0) goto <D.28251>; else goto <D.28252>;
  <D.28251>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4077, "cfg->code_len < cfg->code_size");
  <D.28252>:
  <D.28246>:
  mono_arch_emit_epilog (cfg);
  <D.28244>:
  bb = bb->next_bb;
  <D.25361>:
  if (bb != 0B) goto <D.25360>; else goto <D.25362>;
  <D.25362>:
  mono_arch_emit_exceptions (cfg);
  max_epilog_size = 0;
  D.28236 = cfg->code_len;
  max_epilog_size.105 = (unsigned int) max_epilog_size;
  D.28254 = D.28236 + max_epilog_size.105;
  cfg->code_size = D.28254;
  D.28224 = cfg->method;
  D.28255 = BIT_FIELD_REF <*D.28224, 32, 160>;
  D.28256 = D.28255 & 512;
  if (D.28256 != 0) goto <D.28257>; else goto <D.28258>;
  <D.28257>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.28259 = monoeg_malloc0 (8);
    cfg->dynamic_info = D.28259;
    D.28260 = cfg->dynamic_info;
    D.28261 = mono_code_manager_new_dynamic ();
    D.28260->code_mp = D.28261;
    {
      int ret;

      D.28262 = cfg->domain;
      D.28263 = &D.28262->lock.mutex;
      ret = pthread_mutex_lock (D.28263);
      if (ret != 0) goto <D.28264>; else goto <D.28265>;
      <D.28264>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.28265>:
      D.28266 = ret != 0;
      D.28267 = (long int) D.28266;
      D.28268 = __builtin_expect (D.28267, 0);
      if (D.28268 != 0) goto <D.28269>; else goto <D.28270>;
      <D.28269>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4106, "ret == 0");
      <D.28270>:
    }
    D.28262 = cfg->domain;
    D.28224 = cfg->method;
    D.28260 = cfg->dynamic_info;
    mono_dynamic_code_hash_insert (D.28262, D.28224, D.28260);
    {
      int ret;

      D.28262 = cfg->domain;
      D.28263 = &D.28262->lock.mutex;
      ret = pthread_mutex_unlock (D.28263);
      if (ret != 0) goto <D.28271>; else goto <D.28272>;
      <D.28271>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.28272>:
      D.28273 = ret != 0;
      D.28274 = (long int) D.28273;
      D.28275 = __builtin_expect (D.28274, 0);
      if (D.28275 != 0) goto <D.28276>; else goto <D.28277>;
      <D.28276>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4108, "ret == 0");
      <D.28277>:
    }
    mono_using_xdebug.103 = mono_using_xdebug;
    if (mono_using_xdebug.103 != 0) goto <D.28278>; else goto <D.28279>;
    <D.28278>:
    D.28247 = cfg->code_size;
    D.28280 = D.28247 + unwindlen;
    D.28281 = (int) D.28280;
    code = mono_domain_code_reserve (code_domain, D.28281);
    goto <D.28282>;
    <D.28279>:
    D.28260 = cfg->dynamic_info;
    D.28283 = D.28260->code_mp;
    D.28247 = cfg->code_size;
    D.28280 = D.28247 + unwindlen;
    D.28281 = (int) D.28280;
    code = mono_code_manager_reserve (D.28283, D.28281);
    <D.28282>:
  }
  goto <D.28284>;
  <D.28258>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.28247 = cfg->code_size;
    D.28285 = D.28247 + unwindlen;
    D.28286 = (int) D.28285;
    code = mono_domain_code_reserve (code_domain, D.28286);
  }
  <D.28284>:
  D.28287 = code == 0B;
  D.28288 = (long int) D.28287;
  D.28289 = __builtin_expect (D.28288, 0);
  if (D.28289 != 0) goto <D.28290>; else goto <D.28291>;
  <D.28290>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4126, "code");
  <D.28291>:
  D.28232 = cfg->native_code;
  D.28236 = cfg->code_len;
  memcpy (code, D.28232, D.28236);
  D.28232 = cfg->native_code;
  monoeg_g_free (D.28232);
  cfg->native_code = code;
  D.28232 = cfg->native_code;
  D.28236 = cfg->code_len;
  code = D.28232 + D.28236;
  mono_postprocess_patches (cfg);
  D.28292 = cfg->verbose_level;
  if (D.28292 != 0) goto <D.28293>; else goto <D.28294>;
  <D.28293>:
  {
    char * nm;

    D.28224 = cfg->method;
    nm = mono_method_full_name (D.28224, 1);
    D.28232 = cfg->native_code;
    D.28232 = cfg->native_code;
    D.28236 = cfg->code_len;
    D.28295 = D.28232 + D.28236;
    D.28236 = cfg->code_len;
    D.28262 = cfg->domain;
    D.28296 = D.28262->friendly_name;
    monoeg_g_print ("Method %s emitted at %p to %p (code length %d) [%s]\n", nm, D.28232, D.28295, D.28236, D.28296);
    monoeg_g_free (nm);
  }
  <D.28294>:
  {
    gboolean is_generic;

    is_generic = 0;
    D.28224 = cfg->method;
    D.28255 = BIT_FIELD_REF <*D.28224, 32, 160>;
    D.28299 = D.28255 & 4096;
    if (D.28299 != 0) goto <D.28297>; else goto <D.28300>;
    <D.28300>:
    D.28224 = cfg->method;
    D.28301 = mono_method_get_generic_container (D.28224);
    if (D.28301 != 0B) goto <D.28297>; else goto <D.28302>;
    <D.28302>:
    D.28224 = cfg->method;
    D.28303 = D.28224->klass;
    D.28304 = D.28303->generic_container;
    if (D.28304 != 0B) goto <D.28297>; else goto <D.28305>;
    <D.28305>:
    D.28224 = cfg->method;
    D.28303 = D.28224->klass;
    D.28306 = D.28303->generic_class;
    if (D.28306 != 0B) goto <D.28297>; else goto <D.28298>;
    <D.28297>:
    is_generic = 1;
    <D.28298>:
    D.28307 = cfg->generic_sharing_context;
    if (D.28307 != 0B) goto <D.28308>; else goto <D.28309>;
    <D.28308>:
    D.28310 = is_generic == 0;
    D.28311 = (long int) D.28310;
    D.28312 = __builtin_expect (D.28311, 0);
    if (D.28312 != 0) goto <D.28313>; else goto <D.28314>;
    <D.28313>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4170, "is_generic");
    <D.28314>:
    <D.28309>:
  }
  D.28224 = cfg->method;
  D.28262 = cfg->domain;
  D.28232 = cfg->native_code;
  D.28315 = cfg->patch_info;
  D.28260 = cfg->dynamic_info;
  if (D.28260 != 0B) goto <D.28317>; else goto <D.28318>;
  <D.28317>:
  D.28260 = cfg->dynamic_info;
  iftmp.106 = D.28260->code_mp;
  goto <D.28319>;
  <D.28318>:
  iftmp.106 = 0B;
  <D.28319>:
  D.28320 = cfg->run_cctors;
  D.28321 = (int) D.28320;
  mono_arch_patch_code (D.28224, D.28262, D.28232, D.28315, iftmp.106, D.28321);
  D.28224 = cfg->method;
  D.28255 = BIT_FIELD_REF <*D.28224, 32, 160>;
  D.28256 = D.28255 & 512;
  if (D.28256 != 0) goto <D.28322>; else goto <D.28323>;
  <D.28322>:
  mono_using_xdebug.103 = mono_using_xdebug;
  if (mono_using_xdebug.103 != 0) goto <D.28324>; else goto <D.28325>;
  <D.28324>:
  D.28232 = cfg->native_code;
  D.28247 = cfg->code_size;
  D.28326 = (int) D.28247;
  D.28236 = cfg->code_len;
  D.28237 = (int) D.28236;
  mono_domain_code_commit (code_domain, D.28232, D.28326, D.28237);
  goto <D.28327>;
  <D.28325>:
  D.28260 = cfg->dynamic_info;
  D.28283 = D.28260->code_mp;
  D.28232 = cfg->native_code;
  D.28247 = cfg->code_size;
  D.28326 = (int) D.28247;
  D.28236 = cfg->code_len;
  D.28237 = (int) D.28236;
  mono_code_manager_commit (D.28283, D.28232, D.28326, D.28237);
  <D.28327>:
  goto <D.28328>;
  <D.28323>:
  D.28232 = cfg->native_code;
  D.28247 = cfg->code_size;
  D.28326 = (int) D.28247;
  D.28236 = cfg->code_len;
  D.28237 = (int) D.28236;
  mono_domain_code_commit (code_domain, D.28232, D.28326, D.28237);
  <D.28328>:
  D.28232 = cfg->native_code;
  D.28236 = cfg->code_len;
  D.28237 = (int) D.28236;
  D.28224 = cfg->method;
  mono_profiler_code_buffer_new (D.28232, D.28237, 1, D.28224);
  D.28232 = cfg->native_code;
  D.28236 = cfg->code_len;
  D.28329 = (int) D.28236;
  mono_arch_flush_icache (D.28232, D.28329);
  mono_debug_close_method (cfg);
}


mono_dynamic_code_hash_insert (struct MonoDomain * domain, struct MonoMethod * method, struct MonoJitDynamicMethodInfo * ji)
{
  void * D.28330;
  struct GHashTable * D.28331;
  struct GHashTable * D.28334;

  D.28330 = domain->runtime_info;
  D.28331 = MEM[(struct MonoJitDomainInfo *)D.28330].dynamic_code_hash;
  if (D.28331 == 0B) goto <D.28332>; else goto <D.28333>;
  <D.28332>:
  D.28330 = domain->runtime_info;
  D.28334 = monoeg_g_hash_table_new (0B, 0B);
  MEM[(struct MonoJitDomainInfo *)D.28330].dynamic_code_hash = D.28334;
  <D.28333>:
  D.28330 = domain->runtime_info;
  D.28331 = MEM[(struct MonoJitDomainInfo *)D.28330].dynamic_code_hash;
  monoeg_g_hash_table_insert_replace (D.28331, method, ji, 0);
}


mono_postprocess_patches (struct MonoCompile * cfg)
{
  <unnamed type> D.28335;
  const void * D.28336;
  const char * D.28339;
  char * D.28340;
  char * D.28343;
  struct GHashTable * D.28348;
  <unnamed type> D.28353;
  const void * D.28354;
  struct MonoMethod * D.28355;
  unsigned int D.28356;
  unsigned int D.28357;
  struct MonoJitDynamicMethodInfo * D.28360;
  struct MonoCodeManager * D.28361;
  struct MonoJumpInfoBBTable * D.28362;
  int D.28363;
  unsigned int D.28364;
  unsigned int D.28365;
  int D.28366;
  struct MonoDomain * D.28368;
  struct MonoBasicBlock * * D.28369;
  unsigned int i.107;
  unsigned int D.28371;
  struct MonoBasicBlock * * D.28372;
  struct MonoBasicBlock * D.28373;
  int D.28376;
  _Bool D.28377;
  long int D.28378;
  long int D.28379;
  void * * D.28382;
  void * D.28383;
  unsigned char * D.28385;
  int D.28386;
  sizetype D.28387;
  union mono_mutex_t * D.28388;
  _Bool D.28391;
  long int D.28392;
  long int D.28393;
  void * D.28396;
  struct GHashTable * D.28397;
  struct MonoMethod * D.28398;
  struct GSList * D.28401;
  struct GSList * D.28402;
  _Bool D.28405;
  long int D.28406;
  long int D.28407;
  struct MonoJumpInfo * patch_info;
  int i;

  patch_info = cfg->patch_info;
  goto <D.25285>;
  <D.25284>:
  D.28335 = patch_info->type;
  switch (D.28335) <default: <D.25283>, case 1: <D.25268>, case 4: <D.25277>, case 8: <D.25272>>
  <D.25268>:
  {
    struct MonoJitICallInfo * info;

    D.28336 = patch_info->data.target;
    info = mono_find_jit_icall_by_addr (D.28336);
    if (info != 0B) goto <D.28337>; else goto <D.28338>;
    <D.28337>:
    D.28339 = info->name;
    D.28340 = strstr (D.28339, "ves_array_new_va_");
    if (D.28340 == 0B) goto <D.28341>; else goto <D.28342>;
    <D.28341>:
    D.28339 = info->name;
    D.28343 = strstr (D.28339, "ves_array_element_address_");
    if (D.28343 == 0B) goto <D.28344>; else goto <D.28345>;
    <D.28344>:
    patch_info->type = 7;
    D.28339 = info->name;
    patch_info->data.name = D.28339;
    <D.28345>:
    <D.28342>:
    <D.28338>:
    D.28335 = patch_info->type;
    if (D.28335 == 1) goto <D.28346>; else goto <D.28347>;
    <D.28346>:
    D.28348 = cfg->abs_patches;
    if (D.28348 != 0B) goto <D.28349>; else goto <D.28350>;
    <D.28349>:
    {
      struct MonoJumpInfo * abs_ji;

      D.28348 = cfg->abs_patches;
      D.28336 = patch_info->data.target;
      abs_ji = monoeg_g_hash_table_lookup (D.28348, D.28336);
      if (abs_ji != 0B) goto <D.28351>; else goto <D.28352>;
      <D.28351>:
      D.28353 = abs_ji->type;
      patch_info->type = D.28353;
      D.28354 = abs_ji->data.target;
      patch_info->data.target = D.28354;
      <D.28352>:
    }
    <D.28350>:
    <D.28347>:
    goto <D.25271>;
  }
  <D.25272>:
  {
    void * * table;

    D.28355 = cfg->method;
    D.28356 = BIT_FIELD_REF <*D.28355, 32, 160>;
    D.28357 = D.28356 & 512;
    if (D.28357 != 0) goto <D.28358>; else goto <D.28359>;
    <D.28358>:
    D.28360 = cfg->dynamic_info;
    D.28361 = D.28360->code_mp;
    D.28362 = patch_info->data.table;
    D.28363 = D.28362->table_size;
    D.28364 = (unsigned int) D.28363;
    D.28365 = D.28364 * 4;
    D.28366 = (int) D.28365;
    table = mono_code_manager_reserve (D.28361, D.28366);
    goto <D.28367>;
    <D.28359>:
    D.28368 = cfg->domain;
    D.28362 = patch_info->data.table;
    D.28363 = D.28362->table_size;
    D.28364 = (unsigned int) D.28363;
    D.28365 = D.28364 * 4;
    D.28366 = (int) D.28365;
    table = mono_domain_code_reserve (D.28368, D.28366);
    <D.28367>:
    i = 0;
    goto <D.25275>;
    <D.25274>:
    D.28362 = patch_info->data.table;
    D.28369 = D.28362->table;
    i.107 = (unsigned int) i;
    D.28371 = i.107 * 4;
    D.28372 = D.28369 + D.28371;
    D.28373 = *D.28372;
    if (D.28373 != 0B) goto <D.28374>; else goto <D.28375>;
    <D.28374>:
    D.28362 = patch_info->data.table;
    D.28369 = D.28362->table;
    i.107 = (unsigned int) i;
    D.28371 = i.107 * 4;
    D.28372 = D.28369 + D.28371;
    D.28373 = *D.28372;
    D.28376 = D.28373->native_offset;
    D.28377 = D.28376 == 0;
    D.28378 = (long int) D.28377;
    D.28379 = __builtin_expect (D.28378, 0);
    if (D.28379 != 0) goto <D.28380>; else goto <D.28381>;
    <D.28380>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3815, "patch_info->data.table->table [i]->native_offset");
    <D.28381>:
    i.107 = (unsigned int) i;
    D.28371 = i.107 * 4;
    D.28382 = table + D.28371;
    D.28362 = patch_info->data.table;
    D.28369 = D.28362->table;
    i.107 = (unsigned int) i;
    D.28371 = i.107 * 4;
    D.28372 = D.28369 + D.28371;
    D.28373 = *D.28372;
    D.28376 = D.28373->native_offset;
    D.28383 = (void *) D.28376;
    *D.28382 = D.28383;
    goto <D.28384>;
    <D.28375>:
    i.107 = (unsigned int) i;
    D.28371 = i.107 * 4;
    D.28382 = table + D.28371;
    *D.28382 = 0B;
    <D.28384>:
    i = i + 1;
    <D.25275>:
    D.28362 = patch_info->data.table;
    D.28363 = D.28362->table_size;
    if (D.28363 > i) goto <D.25274>; else goto <D.25276>;
    <D.25276>:
    D.28362 = patch_info->data.table;
    D.28362->table = table;
    goto <D.25271>;
  }
  <D.25277>:
  {
    struct MonoJumpList * jlist;
    struct MonoDomain * domain;
    unsigned char * ip;

    domain = cfg->domain;
    D.28385 = cfg->native_code;
    D.28386 = patch_info->ip.i;
    D.28387 = (sizetype) D.28386;
    ip = D.28385 + D.28387;
    {
      int ret;

      D.28388 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.28388);
      if (ret != 0) goto <D.28389>; else goto <D.28390>;
      <D.28389>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.28390>:
      D.28391 = ret != 0;
      D.28392 = (long int) D.28391;
      D.28393 = __builtin_expect (D.28392, 0);
      if (D.28393 != 0) goto <D.28394>; else goto <D.28395>;
      <D.28394>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3835, "ret == 0");
      <D.28395>:
    }
    D.28396 = domain->runtime_info;
    D.28397 = MEM[(struct MonoJitDomainInfo *)D.28396].jump_target_hash;
    D.28398 = patch_info->data.method;
    jlist = monoeg_g_hash_table_lookup (D.28397, D.28398);
    if (jlist == 0B) goto <D.28399>; else goto <D.28400>;
    <D.28399>:
    jlist = mono_domain_alloc0 (domain, 4);
    D.28396 = domain->runtime_info;
    D.28397 = MEM[(struct MonoJitDomainInfo *)D.28396].jump_target_hash;
    D.28398 = patch_info->data.method;
    monoeg_g_hash_table_insert_replace (D.28397, D.28398, jlist, 0);
    <D.28400>:
    D.28401 = jlist->list;
    D.28402 = monoeg_g_slist_prepend (D.28401, ip);
    jlist->list = D.28402;
    {
      int ret;

      D.28388 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.28388);
      if (ret != 0) goto <D.28403>; else goto <D.28404>;
      <D.28403>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.28404>:
      D.28405 = ret != 0;
      D.28406 = (long int) D.28405;
      D.28407 = __builtin_expect (D.28406, 0);
      if (D.28407 != 0) goto <D.28408>; else goto <D.28409>;
      <D.28408>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3842, "ret == 0");
      <D.28409>:
    }
    goto <D.25271>;
  }
  <D.25283>:
  goto <D.25271>;
  <D.25271>:
  patch_info = patch_info->next;
  <D.25285>:
  if (patch_info != 0B) goto <D.25284>; else goto <D.25286>;
  <D.25286>:
}


mini_get_shared_method_full (struct MonoMethod * method, gboolean all_vt, gboolean is_gsharedvt)
{
  unsigned int D.28414;
  unsigned int D.28415;
  struct MonoClass * D.28417;
  struct MonoGenericContainer * D.28418;
  unsigned int D.28420;
  unsigned int D.28421;
  unsigned int D.28422;
  struct MonoGenericContainer * D.28425;
  struct MonoClass * D.28427;
  struct MonoGenericContainer * D.28428;
  int D.28434;
  int D.28436;
  int iftmp.108;
  int D.28443;
  struct MonoGenericInst * D.28449;
  struct MonoGenericInst * D.28450;
  struct MonoGenericInst * D.28456;
  struct MonoGenericInst * D.28457;
  struct MonoClass * D.28460;
  unsigned int D.28461;
  unsigned int D.28462;
  _Bool D.28463;
  long int D.28464;
  long int D.28465;
  struct MonoMethod * D.28468;
  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.28414 = BIT_FIELD_REF <*method, 32, 160>;
      D.28415 = D.28414 & 2048;
      if (D.28415 != 0) goto <D.28411>; else goto <D.28416>;
      <D.28416>:
      D.28417 = method->klass;
      D.28418 = D.28417->generic_container;
      if (D.28418 != 0B) goto <D.28419>; else goto <D.28412>;
      <D.28419>:
      D.28414 = BIT_FIELD_REF <*method, 32, 160>;
      D.28420 = D.28414 & 4096;
      if (D.28420 == 0) goto <D.28411>; else goto <D.28412>;
      <D.28411>:
      declaring_method = method;
      goto <D.28413>;
      <D.28412>:
      declaring_method = mono_method_get_declaring_generic_method (method);
      <D.28413>:
      D.28421 = BIT_FIELD_REF <*declaring_method, 32, 160>;
      D.28422 = D.28421 & 2048;
      if (D.28422 != 0) goto <D.28423>; else goto <D.28424>;
      <D.28423>:
      D.28425 = mono_method_get_generic_container (declaring_method);
      shared_context = D.28425->context;
      goto <D.28426>;
      <D.28424>:
      D.28427 = declaring_method->klass;
      D.28428 = D.28427->generic_container;
      shared_context = D.28428->context;
      <D.28426>:
      if (method != declaring_method) goto <D.28432>; else goto <D.28429>;
      <D.28432>:
      D.28414 = BIT_FIELD_REF <*method, 32, 160>;
      D.28420 = D.28414 & 4096;
      if (D.28420 != 0) goto <D.28433>; else goto <D.28429>;
      <D.28433>:
      D.28434 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.28434 == 0) goto <D.28430>; else goto <D.28429>;
      <D.28429>:
      if (is_gsharedvt != 0) goto <D.28430>; else goto <D.28435>;
      <D.28435>:
      D.28436 = mini_is_gsharedvt_sharable_method (method);
      if (D.28436 != 0) goto <D.28430>; else goto <D.28431>;
      <D.28430>:
      {
        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.28438>; else goto <D.28441>;
        <D.28441>:
        if (partial == 0) goto <D.28442>; else goto <D.28439>;
        <D.28442>:
        D.28443 = mini_is_gsharedvt_sharable_method (method);
        if (D.28443 != 0) goto <D.28438>; else goto <D.28439>;
        <D.28438>:
        iftmp.108 = 1;
        goto <D.28440>;
        <D.28439>:
        iftmp.108 = 0;
        <D.28440>:
        gsharedvt = iftmp.108;
        D.28427 = declaring_method->klass;
        class_container = D.28427->generic_container;
        method_container = mono_method_get_generic_container (declaring_method);
        if (context != 0B) goto <D.28444>; else goto <D.28445>;
        <D.28444>:
        inst = context->class_inst;
        goto <D.28446>;
        <D.28445>:
        inst = shared_context.class_inst;
        <D.28446>:
        if (inst != 0B) goto <D.28447>; else goto <D.28448>;
        <D.28447>:
        D.28449 = shared_context.class_inst;
        D.28450 = get_shared_inst (inst, D.28449, class_container, all_vt, gsharedvt);
        shared_context.class_inst = D.28450;
        <D.28448>:
        if (context != 0B) goto <D.28451>; else goto <D.28452>;
        <D.28451>:
        inst = context->method_inst;
        goto <D.28453>;
        <D.28452>:
        inst = shared_context.method_inst;
        <D.28453>:
        if (inst != 0B) goto <D.28454>; else goto <D.28455>;
        <D.28454>:
        D.28456 = shared_context.method_inst;
        D.28457 = get_shared_inst (inst, D.28456, method_container, all_vt, gsharedvt);
        shared_context.method_inst = D.28457;
        <D.28455>:
        partial = 1;
      }
      <D.28431>:
      res = mono_class_inflate_generic_method (declaring_method, &shared_context);
      if (partial == 0) goto <D.28458>; else goto <D.28459>;
      <D.28458>:
      D.28460 = res->klass;
      D.28461 = BIT_FIELD_REF <*D.28460, 32, 192>;
      D.28462 = D.28461 & 8;
      D.28463 = D.28462 != 0;
      D.28464 = (long int) D.28463;
      D.28465 = __builtin_expect (D.28464, 0);
      if (D.28465 != 0) goto <D.28466>; else goto <D.28467>;
      <D.28466>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4777, "!res->klass->is_inflated");
      <D.28467>:
      <D.28459>:
      D.28468 = res;
      return D.28468;
    }
  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.28471;
  unsigned int D.28472;
  unsigned int D.28473;
  struct MonoType * D.28478;
  int D.28479;
  unsigned char D.28481;
  unsigned int i.109;
  unsigned int D.28484;
  struct MonoType * * D.28485;
  struct MonoType * D.28486;
  struct MonoType * D.28489;
  struct MonoType * D.28493;
  int D.28495;
  struct MonoGenericInst * D.28496;
  struct MonoGenericInst * res;
  struct MonoType * * type_argv;
  int i;

  D.28471 = inst->type_argc;
  D.28472 = (unsigned int) D.28471;
  D.28473 = D.28472 * 4;
  type_argv = monoeg_malloc0 (D.28473);
  i = 0;
  goto <D.25510>;
  <D.25509>:
  if (all_vt == 0) goto <D.28477>; else goto <D.28474>;
  <D.28477>:
  D.28478 = inst->type_argv[i];
  D.28479 = mono_type_is_reference (D.28478);
  if (D.28479 != 0) goto <D.28475>; else goto <D.28480>;
  <D.28480>:
  D.28478 = inst->type_argv[i];
  D.28481 = D.28478->type;
  if (D.28481 == 19) goto <D.28475>; else goto <D.28482>;
  <D.28482>:
  D.28478 = inst->type_argv[i];
  D.28481 = D.28478->type;
  if (D.28481 == 30) goto <D.28475>; else goto <D.28474>;
  <D.28475>:
  i.109 = (unsigned int) i;
  D.28484 = i.109 * 4;
  D.28485 = type_argv + D.28484;
  D.28486 = shared_inst->type_argv[i];
  *D.28485 = D.28486;
  goto <D.28476>;
  <D.28474>:
  if (all_vt != 0) goto <D.28487>; else goto <D.28488>;
  <D.28487>:
  i.109 = (unsigned int) i;
  D.28484 = i.109 * 4;
  D.28485 = type_argv + D.28484;
  D.28486 = shared_inst->type_argv[i];
  D.28489 = get_gsharedvt_type (D.28486);
  *D.28485 = D.28489;
  goto <D.28490>;
  <D.28488>:
  if (gsharedvt != 0) goto <D.28491>; else goto <D.28492>;
  <D.28491>:
  i.109 = (unsigned int) i;
  D.28484 = i.109 * 4;
  D.28485 = type_argv + D.28484;
  D.28486 = shared_inst->type_argv[i];
  D.28493 = get_gsharedvt_type (D.28486);
  *D.28485 = D.28493;
  goto <D.28494>;
  <D.28492>:
  i.109 = (unsigned int) i;
  D.28484 = i.109 * 4;
  D.28485 = type_argv + D.28484;
  D.28478 = inst->type_argv[i];
  *D.28485 = D.28478;
  <D.28494>:
  <D.28490>:
  <D.28476>:
  i = i + 1;
  <D.25510>:
  D.28471 = inst->type_argc;
  D.28495 = (int) D.28471;
  if (D.28495 > i) goto <D.25509>; else goto <D.25511>;
  <D.25511>:
  D.28471 = inst->type_argc;
  D.28495 = (int) D.28471;
  res = mono_metadata_get_generic_inst (D.28495, type_argv);
  monoeg_g_free (type_argv);
  D.28496 = res;
  return D.28496;
}


get_gsharedvt_type (struct MonoType * t)
{
  int iftmp.110;
  struct MonoGenericContainer * D.28502;
  struct MonoGenericParamInfo * D.28504;
  _Bool D.28505;
  long int D.28506;
  long int D.28507;
  struct GHashTable * D.28512;
  struct GHashTable * D.28515;
  struct MonoType * D.28518;
  struct MonoImage * D.28520;
  struct MonoGenericParam * par;
  struct MonoGenericParam * copy;
  struct MonoType * res;
  struct MonoImage * image;

  par = t->data.generic_param;
  image = 0B;
  D.28502 = par->owner;
  if (D.28502 == 0B) goto <D.28499>; else goto <D.28503>;
  <D.28503>:
  D.28504 = &MEM[(struct MonoGenericParamFull *)par].info;
  if (D.28504 == 0B) goto <D.28499>; else goto <D.28500>;
  <D.28499>:
  iftmp.110 = 1;
  goto <D.28501>;
  <D.28500>:
  iftmp.110 = 0;
  <D.28501>:
  D.28505 = iftmp.110 != 0;
  D.28506 = (long int) D.28505;
  D.28507 = __builtin_expect (D.28506, 0);
  if (D.28507 != 0) goto <D.28508>; else goto <D.28509>;
  <D.28508>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4607, "mono_generic_param_info (par)");
  <D.28509>:
  D.28502 = par->owner;
  if (D.28502 != 0B) goto <D.28510>; else goto <D.28511>;
  <D.28510>:
  D.28502 = par->owner;
  image = D.28502->image;
  mono_image_lock (image);
  D.28512 = image->gsharedvt_types;
  if (D.28512 == 0B) goto <D.28513>; else goto <D.28514>;
  <D.28513>:
  D.28515 = monoeg_g_hash_table_new (0B, 0B);
  image->gsharedvt_types = D.28515;
  <D.28514>:
  D.28512 = image->gsharedvt_types;
  res = monoeg_g_hash_table_lookup (D.28512, par);
  mono_image_unlock (image);
  if (res != 0B) goto <D.28516>; else goto <D.28517>;
  <D.28516>:
  D.28518 = res;
  return D.28518;
  <D.28517>:
  copy = mono_image_alloc0 (image, 32);
  memcpy (copy, par, 32);
  goto <D.28519>;
  <D.28511>:
  copy = monoeg_g_memdup (par, 32);
  <D.28519>:
  copy->owner = 0B;
  D.28520 = mono_defaults.corlib;
  copy->image = D.28520;
  copy->serial = 1;
  res = mono_metadata_type_dup (0B, t);
  res->data.generic_param = copy;
  D.28502 = par->owner;
  if (D.28502 != 0B) goto <D.28521>; else goto <D.28522>;
  <D.28521>:
  mono_image_lock (image);
  D.28512 = image->gsharedvt_types;
  monoeg_g_hash_table_insert_replace (D.28512, par, res, 0);
  mono_image_unlock (image);
  <D.28522>:
  D.28518 = res;
  return D.28518;
}


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

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


mini_init_gsctx (struct MonoGenericContext * context, struct MonoGenericSharingContext * gsctx)
{
  struct MonoGenericInst * D.28526;
  <unnamed-unsigned:22> D.28529;
  unsigned int D.28530;
  unsigned int D.28531;
  void * D.28532;
  unsigned char D.28535;
  struct MonoGenericParam * D.28537;
  short unsigned int D.28538;
  gboolean * D.28541;
  unsigned int i.111;
  unsigned int D.28543;
  gboolean * D.28544;
  int D.28545;
  struct MonoGenericInst * D.28546;
  void * D.28549;
  unsigned char D.28552;
  struct MonoGenericParam * D.28554;
  short unsigned int D.28555;
  gboolean * D.28558;
  gboolean * D.28559;
  struct MonoGenericInst * inst;
  int i;

  memset (gsctx, 0, 8);
  D.28526 = context->class_inst;
  if (D.28526 != 0B) goto <D.28527>; else goto <D.28528>;
  <D.28527>:
  inst = context->class_inst;
  D.28529 = inst->type_argc;
  D.28530 = (unsigned int) D.28529;
  D.28531 = D.28530 * 4;
  D.28532 = monoeg_malloc0 (D.28531);
  gsctx->var_is_vt = D.28532;
  i = 0;
  goto <D.25537>;
  <D.25536>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.28535 = type->type;
    if (D.28535 == 19) goto <D.28533>; else goto <D.28536>;
    <D.28536>:
    D.28535 = type->type;
    if (D.28535 == 30) goto <D.28533>; else goto <D.28534>;
    <D.28533>:
    D.28537 = type->data.generic_param;
    D.28538 = D.28537->serial;
    if (D.28538 == 1) goto <D.28539>; else goto <D.28540>;
    <D.28539>:
    D.28541 = gsctx->var_is_vt;
    i.111 = (unsigned int) i;
    D.28543 = i.111 * 4;
    D.28544 = D.28541 + D.28543;
    *D.28544 = 1;
    <D.28540>:
    <D.28534>:
  }
  i = i + 1;
  <D.25537>:
  D.28529 = inst->type_argc;
  D.28545 = (int) D.28529;
  if (D.28545 > i) goto <D.25536>; else goto <D.25538>;
  <D.25538>:
  <D.28528>:
  D.28546 = context->method_inst;
  if (D.28546 != 0B) goto <D.28547>; else goto <D.28548>;
  <D.28547>:
  inst = context->method_inst;
  D.28529 = inst->type_argc;
  D.28530 = (unsigned int) D.28529;
  D.28531 = D.28530 * 4;
  D.28549 = monoeg_malloc0 (D.28531);
  gsctx->mvar_is_vt = D.28549;
  i = 0;
  goto <D.25541>;
  <D.25540>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.28552 = type->type;
    if (D.28552 == 19) goto <D.28550>; else goto <D.28553>;
    <D.28553>:
    D.28552 = type->type;
    if (D.28552 == 30) goto <D.28550>; else goto <D.28551>;
    <D.28550>:
    D.28554 = type->data.generic_param;
    D.28555 = D.28554->serial;
    if (D.28555 == 1) goto <D.28556>; else goto <D.28557>;
    <D.28556>:
    D.28558 = gsctx->mvar_is_vt;
    i.111 = (unsigned int) i;
    D.28543 = i.111 * 4;
    D.28559 = D.28558 + D.28543;
    *D.28559 = 1;
    <D.28557>:
    <D.28551>:
  }
  i = i + 1;
  <D.25541>:
  D.28529 = inst->type_argc;
  D.28545 = (int) D.28529;
  if (D.28545 > i) goto <D.25540>; else goto <D.25542>;
  <D.25542>:
  <D.28548>:
}


mini_method_compile (struct MonoMethod * method, guint32 opts, struct MonoDomain * domain, JitFlags flags, int parts)
{
  unsigned int D.28560;
  _Bool D.28561;
  unsigned int D.28562;
  _Bool D.28563;
  unsigned int D.28564;
  _Bool D.28565;
  <unnamed type> D.28566;
  unsigned int D.28567;
  int iftmp.112;
  struct MonoClass * D.28578;
  int D.28579;
  unsigned int D.28581;
  unsigned int D.28583;
  unsigned int D.28584;
  struct MonoGenericContainer * D.28586;
  struct MonoGenericClass * D.28588;
  int D.28590;
  int iftmp.113;
  int D.28595;
  int D.28598;
  long unsigned int D.28604;
  long unsigned int D.28605;
  int D.28607;
  long unsigned int D.28610;
  long unsigned int D.28611;
  int D.28612;
  int D.28615;
  int D.28622;
  int D.28625;
  _Bool D.28626;
  long int D.28627;
  long int D.28628;
  _Bool D.28636;
  long int D.28637;
  long int D.28638;
  struct MonoMethod * D.28642;
  struct MonoMethodHeader * D.28643;
  struct MonoMemPool * D.28644;
  <unnamed type> D.28645;
  unsigned char D.28646;
  <unnamed-unsigned:1> D.28647;
  int mini_verbose.114;
  unsigned int mini_verbose.115;
  unsigned char D.28650;
  <unnamed-unsigned:1> D.28651;
  unsigned char D.28652;
  <unnamed-unsigned:1> D.28653;
  <unnamed-unsigned:1> D.28654;
  int D.28655;
  unsigned char D.28656;
  <unnamed-unsigned:1> D.28657;
  int D.28658;
  unsigned char D.28659;
  <unnamed-unsigned:1> D.28660;
  int D.28661;
  unsigned char D.28662;
  <unnamed-unsigned:1> D.28663;
  struct MonoGenericSharingContext * D.28666;
  unsigned char D.28667;
  <unnamed-unsigned:1> D.28668;
  struct GHashTable * D.28669;
  unsigned int D.28670;
  unsigned int D.28671;
  struct GPtrArray * D.28674;
  unsigned int D.28677;
  unsigned int D.28678;
  struct MonoCompile * D.28685;
  struct MonoGenericSharingContext * D.28688;
  int D.28691;
  unsigned int D.28695;
  _Bool D.28696;
  long int D.28697;
  long int D.28698;
  unsigned int D.28704;
  unsigned int D.28705;
  _Bool D.28706;
  long int D.28707;
  long int D.28708;
  _Bool D.28714;
  long int D.28715;
  long int D.28716;
  const char * D.28721;
  gchar * D.28722;
  unsigned char D.28729;
  unsigned int D.28730;
  const char * D.28732;
  gchar * D.28733;
  int D.28736;
  unsigned int D.28739;
  unsigned int D.28740;
  unsigned int D.28741;
  unsigned int D.28742;
  unsigned int D.28743;
  int mono_using_xdebug.116;
  unsigned int D.28749;
  const gchar * D.28750;
  char * D.28756;
  char * D.28758;
  int D.28759;
  int D.25581;
  const gchar * D.28762;
  struct MonoMemPool * D.28765;
  <unnamed-unsigned:15> D.28766;
  unsigned int D.28767;
  unsigned int D.28768;
  void * D.28769;
  unsigned int D.28770;
  const char * iftmp.117;
  int D.28774;
  const char * iftmp.118;
  unsigned int D.28783;
  unsigned int D.28786;
  int count.119;
  int count.120;
  struct MonoExceptionClause * D.28789;
  unsigned int D.28792;
  unsigned int D.28793;
  unsigned int D.28796;
  unsigned int D.28799;
  struct MonoRegState * D.28802;
  unsigned int D.28803;
  struct MonoRegState * D.28806;
  int D.28807;
  unsigned int D.28808;
  unsigned int D.28809;
  int D.28812;
  struct MonoDebugOptions * D.28815;
  int D.28816;
  unsigned int D.28819;
  unsigned int D.28824;
  _Bool D.28831;
  long int D.28832;
  long int D.28833;
  int D.28838;
  unsigned int D.28839;
  unsigned int D.28840;
  unsigned int D.28841;
  int D.28842;
  struct MonoInst * D.28845;
  unsigned char D.28848;
  unsigned char D.28849;
  int D.28850;
  struct MonoInst * D.28851;
  int D.28852;
  int D.28853;
  const unsigned char * D.28854;
  int D.28855;
  struct MonoBasicBlock * D.28856;
  struct MonoInst * D.28857;
  unsigned int D.28861;
  unsigned int D.28862;
  unsigned int D.28865;
  unsigned int D.28868;
  unsigned int D.28871;
  unsigned int D.28874;
  unsigned int D.28881;
  unsigned int D.28883;
  unsigned int D.28884;
  void * D.28885;
  struct MonoBasicBlock * D.28886;
  struct MonoBasicBlock * * D.28887;
  int dfn.121;
  int D.28889;
  unsigned int D.28890;
  unsigned int D.28893;
  unsigned int D.28894;
  unsigned int D.28895;
  unsigned int D.28898;
  int D.28903;
  struct MonoInst * D.28904;
  struct MonoBasicBlock * * D.28905;
  struct MonoBasicBlock * D.28906;
  short int D.28907;
  unsigned int D.28910;
  unsigned int D.28914;
  unsigned int D.28915;
  unsigned int D.28924;
  unsigned int D.28925;
  unsigned int D.28928;
  unsigned int D.28937;
  unsigned int D.28938;
  unsigned int D.28949;
  unsigned int D.28950;
  unsigned int D.28953;
  void * D.28962;
  unsigned int D.28974;
  struct MonoInst * D.28977;
  unsigned int D.28980;
  _Bool D.28981;
  long int D.28982;
  long int D.28983;
  _Bool D.28986;
  long int D.28987;
  long int D.28988;
  void * D.28991;
  unsigned int D.28992;
  signed int D.28993;
  int D.28994;
  long long int D.28995;
  signed int D.28996;
  signed int D.28997;
  unsigned int D.28998;
  unsigned int D.29001;
  unsigned int D.29006;
  unsigned int D.29007;
  void * D.29014;
  unsigned int D.29015;
  unsigned int D.29016;
  regmask_t * D.29019;
  int need_local_opts.122;
  struct MonoInst * D.29034;
  short unsigned int D.29037;
  short unsigned int D.29038;
  short unsigned int D.29040;
  short unsigned int D.29042;
  struct MonoBasicBlock * * D.29043;
  struct MonoBasicBlock * * D.29044;
  struct MonoBasicBlock * D.29045;
  struct MonoBasicBlock * D.29048;
  struct MonoInst * D.29058;
  struct MonoInst * D.29060;
  unsigned char D.29061;
  struct MonoBasicBlock * D.29062;
  struct MonoBasicBlock * D.29064;
  unsigned int D.29065;
  unsigned int D.29066;
  short unsigned int D.29067;
  int D.29072;
  unsigned int D.29075;
  struct MonoJitInfo * D.29082;
  unsigned char * D.29087;
  unsigned int D.29088;
  int D.29089;
  char * D.29090;
  struct MonoDomain * D.29093;
  union mono_mutex_t * D.29094;
  _Bool D.29097;
  long int D.29098;
  long int D.29099;
  struct MonoJitInfo * D.29102;
  unsigned int D.29103;
  struct MonoJitDynamicMethodInfo * D.29106;
  _Bool D.29109;
  long int D.29110;
  long int D.29111;
  struct MonoPerfCounters * mono_perfcounters.123;
  unsigned int D.29115;
  unsigned int D.29116;
  unsigned int D.29117;
  unsigned int D.29118;
  int D.29119;
  unsigned int D.29120;
  unsigned int D.29121;
  int D.29122;
  int D.29123;
  int D.29126;
  char * D.29129;
  const char * D.29130;
  const char * D.29131;
  gchar * D.29132;
  int D.29133;
  unsigned int D.29134;
  unsigned int D.29135;
  int D.29136;
  char * D.29141;
  gchar * D.29142;
  int D.29143;
  unsigned int D.29144;
  unsigned int D.29145;
  int D.29146;
  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.28560 = flags & 1;
      D.28561 = D.28560 != 0;
      run_cctors = (gboolean) D.28561;
      D.28562 = flags & 2;
      D.28563 = D.28562 != 0;
      compile_aot = (gboolean) D.28563;
      D.28564 = flags & 4;
      D.28565 = D.28564 != 0;
      full_aot = (gboolean) D.28565;
      InterlockedIncrement (&mono_jit_stats.methods_compiled);
      D.28566 = mono_profiler_get_events ();
      D.28567 = D.28566 & 16;
      if (D.28567 != 0) goto <D.28568>; else goto <D.28569>;
      <D.28568>:
      mono_profiler_method_jit (method);
      <D.28569>:
      if (0 != 0) goto <D.28570>; else goto <D.28571>;
      <D.28570>:
      <D.28571>:
      if (compile_aot != 0) goto <D.28572>; else goto <D.28573>;
      <D.28572>:
      D.28578 = method->klass;
      D.28579 = mono_class_generic_sharing_enabled (D.28578);
      if (D.28579 != 0) goto <D.28580>; else goto <D.28575>;
      <D.28580>:
      D.28581 = opts & 33554432;
      if (D.28581 != 0) goto <D.28582>; else goto <D.28575>;
      <D.28582>:
      D.28583 = BIT_FIELD_REF <*method, 32, 160>;
      D.28584 = D.28583 & 2048;
      if (D.28584 != 0) goto <D.28576>; else goto <D.28585>;
      <D.28585>:
      D.28578 = method->klass;
      D.28586 = D.28578->generic_container;
      if (D.28586 != 0B) goto <D.28576>; else goto <D.28587>;
      <D.28587>:
      D.28578 = method->klass;
      D.28588 = D.28578->generic_class;
      if (D.28588 == 0B) goto <D.28589>; else goto <D.28575>;
      <D.28589>:
      D.28590 = mono_method_is_generic_sharable_full (method, 1, 0, 0);
      if (D.28590 != 0) goto <D.28576>; else goto <D.28575>;
      <D.28576>:
      iftmp.112 = 1;
      goto <D.28577>;
      <D.28575>:
      iftmp.112 = 0;
      <D.28577>:
      try_generic_shared = iftmp.112;
      goto <D.28591>;
      <D.28573>:
      D.28578 = method->klass;
      D.28595 = mono_class_generic_sharing_enabled (D.28578);
      if (D.28595 != 0) goto <D.28596>; else goto <D.28593>;
      <D.28596>:
      D.28581 = opts & 33554432;
      if (D.28581 != 0) goto <D.28597>; else goto <D.28593>;
      <D.28597>:
      D.28598 = mono_method_is_generic_sharable (method, 0);
      if (D.28598 != 0) goto <D.28599>; else goto <D.28593>;
      <D.28599>:
      iftmp.113 = 1;
      goto <D.28594>;
      <D.28593>:
      iftmp.113 = 0;
      <D.28594>:
      try_generic_shared = iftmp.113;
      <D.28591>:
      D.28581 = opts & 33554432;
      if (D.28581 != 0) goto <D.28600>; else goto <D.28601>;
      <D.28600>:
      if (try_generic_shared != 0) goto <D.28602>; else goto <D.28603>;
      <D.28602>:
      D.28604 = mono_stats.generics_sharable_methods;
      D.28605 = D.28604 + 1;
      mono_stats.generics_sharable_methods = D.28605;
      goto <D.28606>;
      <D.28603>:
      D.28607 = mono_method_is_generic_impl (method);
      if (D.28607 != 0) goto <D.28608>; else goto <D.28609>;
      <D.28608>:
      D.28610 = mono_stats.generics_unsharable_methods;
      D.28611 = D.28610 + 1;
      mono_stats.generics_unsharable_methods = D.28611;
      <D.28609>:
      <D.28606>:
      <D.28601>:
      D.28612 = mini_is_gsharedvt_sharable_method (method);
      if (D.28612 != 0) goto <D.28613>; else goto <D.28614>;
      <D.28613>:
      D.28615 = mono_debug_count ();
      if (D.28615 == 0) goto <D.28616>; else goto <D.28617>;
      <D.28616>:
      try_generic_shared = 0;
      <D.28617>:
      if (compile_aot != 0) goto <D.28618>; else goto <D.28619>;
      <D.28618>:
      try_generic_shared = 0;
      <D.28619>:
      <D.28614>:
      D.28622 = is_gsharedvt_method (method);
      if (D.28622 != 0) goto <D.28620>; else goto <D.28623>;
      <D.28623>:
      if (compile_aot != 0) goto <D.28624>; else goto <D.28621>;
      <D.28624>:
      D.28625 = is_open_method (method);
      if (D.28625 != 0) goto <D.28620>; else goto <D.28621>;
      <D.28620>:
      method_is_gshared = 1;
      D.28626 = compile_aot == 0;
      D.28627 = (long int) D.28626;
      D.28628 = __builtin_expect (D.28627, 0);
      if (D.28628 != 0) goto <D.28629>; else goto <D.28630>;
      <D.28629>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4884, "compile_aot");
      <D.28630>:
      try_generic_shared = 1;
      <D.28621>:
      restart_compile:
      if (method_is_gshared != 0) goto <D.28631>; else goto <D.28632>;
      <D.28631>:
      method_to_compile = method;
      goto <D.28633>;
      <D.28632>:
      if (try_generic_shared != 0) goto <D.28634>; else goto <D.28635>;
      <D.28634>:
      method_to_compile = mini_get_shared_method (method);
      D.28636 = method_to_compile == 0B;
      D.28637 = (long int) D.28636;
      D.28638 = __builtin_expect (D.28637, 0);
      if (D.28638 != 0) goto <D.28639>; else goto <D.28640>;
      <D.28639>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4898, "method_to_compile");
      <D.28640>:
      goto <D.28641>;
      <D.28635>:
      method_to_compile = method;
      <D.28641>:
      <D.28633>:
      cfg = monoeg_malloc0 (712);
      cfg->method = method_to_compile;
      D.28642 = cfg->method;
      D.28643 = mono_method_get_header (D.28642);
      cfg->header = D.28643;
      D.28644 = mono_mempool_new ();
      cfg->mempool = D.28644;
      cfg->opt = opts;
      D.28645 = mono_profiler_get_events ();
      cfg->prof_options = D.28645;
      D.28646 = (unsigned char) run_cctors;
      D.28647 = (<unnamed-unsigned:1>) D.28646;
      cfg->run_cctors = D.28647;
      cfg->domain = domain;
      mini_verbose.114 = mini_verbose;
      mini_verbose.115 = (unsigned int) mini_verbose.114;
      cfg->verbose_level = mini_verbose.115;
      D.28650 = (unsigned char) compile_aot;
      D.28651 = (<unnamed-unsigned:1>) D.28650;
      cfg->compile_aot = D.28651;
      D.28652 = (unsigned char) full_aot;
      D.28653 = (<unnamed-unsigned:1>) D.28652;
      cfg->full_aot = D.28653;
      D.28654 = method->skip_visibility;
      cfg->skip_visibility = D.28654;
      cfg->orig_method = method;
      D.28655 = debug_options.gen_seq_points;
      D.28656 = (unsigned char) D.28655;
      D.28657 = (<unnamed-unsigned:1>) D.28656;
      cfg->gen_seq_points = D.28657;
      D.28658 = debug_options.explicit_null_checks;
      D.28659 = (unsigned char) D.28658;
      D.28660 = (<unnamed-unsigned:1>) D.28659;
      cfg->explicit_null_checks = D.28660;
      D.28661 = debug_options.soft_breakpoints;
      D.28662 = (unsigned char) D.28661;
      D.28663 = (<unnamed-unsigned:1>) D.28662;
      cfg->soft_breakpoints = D.28663;
      if (try_generic_shared != 0) goto <D.28664>; else goto <D.28665>;
      <D.28664>:
      D.28666 = &cfg->gsctx;
      cfg->generic_sharing_context = D.28666;
      <D.28665>:
      D.28667 = (unsigned char) try_llvm;
      D.28668 = (<unnamed-unsigned:1>) D.28667;
      cfg->compile_llvm = D.28668;
      D.28669 = monoeg_g_hash_table_new (0B, 0B);
      cfg->token_info_hash = D.28669;
      D.28670 = BIT_FIELD_REF <*cfg, 32, 3424>;
      D.28671 = D.28670 & 32;
      if (D.28671 != 0) goto <D.28672>; else goto <D.28673>;
      <D.28672>:
      D.28674 = monoeg_g_ptr_array_new ();
      cfg->seq_points = D.28674;
      <D.28673>:
      D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.28678 = D.28677 & 64;
      if (D.28678 != 0) goto <D.28679>; else goto <D.28680>;
      <D.28679>:
      if (try_generic_shared == 0) goto <D.28681>; else goto <D.28682>;
      <D.28681>:
      D.28583 = BIT_FIELD_REF <*method, 32, 160>;
      D.28584 = D.28583 & 2048;
      if (D.28584 != 0) goto <D.28675>; else goto <D.28683>;
      <D.28683>:
      D.28578 = method->klass;
      D.28586 = D.28578->generic_container;
      if (D.28586 != 0B) goto <D.28675>; else goto <D.28684>;
      <D.28684>:
      if (method_is_gshared != 0) goto <D.28675>; else goto <D.28676>;
      <D.28675>:
      cfg->exception_type = 11;
      D.28685 = cfg;
      return D.28685;
      <D.28676>:
      <D.28682>:
      <D.28680>:
      D.28688 = cfg->generic_sharing_context;
      if (D.28688 != 0B) goto <D.28689>; else goto <D.28690>;
      <D.28689>:
      D.28691 = mini_is_gsharedvt_sharable_method (method);
      if (D.28691 != 0) goto <D.28686>; else goto <D.28692>;
      <D.28692>:
      if (method_is_gshared != 0) goto <D.28686>; else goto <D.28687>;
      <D.28686>:
      {
        struct MonoMethodInflated * inflated;
        struct MonoGenericContext * context;

        if (method_is_gshared != 0) goto <D.28693>; else goto <D.28694>;
        <D.28693>:
        D.28583 = BIT_FIELD_REF <*method, 32, 160>;
        D.28695 = D.28583 & 4096;
        D.28696 = D.28695 == 0;
        D.28697 = (long int) D.28696;
        D.28698 = __builtin_expect (D.28697, 0);
        if (D.28698 != 0) goto <D.28699>; else goto <D.28700>;
        <D.28699>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4939, "method->is_inflated");
        <D.28700>:
        inflated = method;
        context = &inflated->context;
        D.28626 = compile_aot == 0;
        D.28627 = (long int) D.28626;
        D.28628 = __builtin_expect (D.28627, 0);
        if (D.28628 != 0) goto <D.28701>; else goto <D.28702>;
        <D.28701>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4944, "compile_aot");
        <D.28702>:
        goto <D.28703>;
        <D.28694>:
        D.28704 = BIT_FIELD_REF <*method_to_compile, 32, 160>;
        D.28705 = D.28704 & 4096;
        D.28706 = D.28705 == 0;
        D.28707 = (long int) D.28706;
        D.28708 = __builtin_expect (D.28707, 0);
        if (D.28708 != 0) goto <D.28709>; else goto <D.28710>;
        <D.28709>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4946, "method_to_compile->is_inflated");
        <D.28710>:
        inflated = method_to_compile;
        context = &inflated->context;
        <D.28703>:
        D.28666 = &cfg->gsctx;
        mini_init_gsctx (context, D.28666);
        cfg->gsharedvt = 1;
        cfg->disable_llvm = 1;
      }
      <D.28687>:
      <D.28690>:
      D.28688 = cfg->generic_sharing_context;
      if (D.28688 != 0B) goto <D.28711>; else goto <D.28712>;
      <D.28711>:
      method_to_register = method_to_compile;
      goto <D.28713>;
      <D.28712>:
      D.28714 = method != method_to_compile;
      D.28715 = (long int) D.28714;
      D.28716 = __builtin_expect (D.28715, 0);
      if (D.28716 != 0) goto <D.28717>; else goto <D.28718>;
      <D.28717>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4961, "method == method_to_compile");
      <D.28718>:
      method_to_register = method;
      <D.28713>:
      cfg->method_to_register = method_to_register;
      mono_error_init (&err);
      D.28642 = cfg->method;
      sig = mono_method_signature_checked (D.28642, &err);
      if (sig == 0B) goto <D.28719>; else goto <D.28720>;
      <D.28719>:
      cfg->exception_type = 7;
      D.28721 = mono_error_get_message (&err);
      D.28722 = monoeg_strdup (D.28721);
      cfg->exception_message = D.28722;
      mono_error_cleanup (&err);
      if (0 != 0) goto <D.28723>; else goto <D.28724>;
      <D.28723>:
      <D.28724>:
      D.28685 = cfg;
      return D.28685;
      <D.28720>:
      header = cfg->header;
      if (header == 0B) goto <D.28725>; else goto <D.28726>;
      <D.28725>:
      {
        struct MonoLoaderError * error;

        error = mono_loader_get_last_error ();
        if (error != 0B) goto <D.28727>; else goto <D.28728>;
        <D.28727>:
        D.28729 = error->exception_type;
        D.28730 = (unsigned int) D.28729;
        cfg->exception_type = D.28730;
        goto <D.28731>;
        <D.28728>:
        cfg->exception_type = 3;
        D.28642 = cfg->method;
        D.28732 = D.28642->name;
        D.28733 = monoeg_g_strdup_printf ("Missing or incorrect header for method %s", D.28732);
        cfg->exception_message = D.28733;
        <D.28731>:
        if (0 != 0) goto <D.28734>; else goto <D.28735>;
        <D.28734>:
        <D.28735>:
        D.28685 = cfg;
        return D.28685;
      }
      <D.28726>:
      D.28736 = debug_options.mdb_optimizations;
      if (D.28736 != 0) goto <D.28737>; else goto <D.28738>;
      <D.28737>:
      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.28739 = cfg->opt;
      D.28740 = D.28739 & 4294967231;
      cfg->opt = D.28740;
      D.28739 = cfg->opt;
      D.28741 = D.28739 & 4294967291;
      cfg->opt = D.28741;
      D.28739 = cfg->opt;
      D.28742 = D.28739 & 4294967263;
      cfg->opt = D.28742;
      D.28739 = cfg->opt;
      D.28743 = D.28739 & 4294967279;
      cfg->opt = D.28743;
      cfg->disable_out_of_line_bblocks = 1;
      <D.28738>:
      mono_using_xdebug.116 = mono_using_xdebug;
      if (mono_using_xdebug.116 != 0) goto <D.28745>; else goto <D.28746>;
      <D.28745>:
      cfg->disable_reuse_registers = 1;
      cfg->disable_reuse_stack_slots = 1;
      cfg->extend_live_ranges = 1;
      cfg->compute_precise_live_ranges = 1;
      <D.28746>:
      mini_gc_init_cfg (cfg);
      if (0 != 0) goto <D.28747>; else goto <D.28748>;
      <D.28747>:
      D.28739 = cfg->opt;
      D.28749 = D.28739 | 262144;
      cfg->opt = D.28749;
      <D.28748>:
      D.28750 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
      if (D.28750 != 0B) goto <D.28751>; else goto <D.28752>;
      <D.28751>:
      {
        const char * name;

        name = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
        D.28756 = __builtin_strchr (name, 46);
        if (D.28756 > name) goto <D.28753>; else goto <D.28757>;
        <D.28757>:
        D.28758 = __builtin_strchr (name, 58);
        if (D.28758 != 0B) goto <D.28753>; else goto <D.28754>;
        <D.28753>:
        {
          struct MonoMethodDesc * desc;

          desc = mono_method_desc_new (name, 1);
          D.28642 = cfg->method;
          D.28759 = mono_method_desc_full_match (desc, D.28642);
          if (D.28759 != 0) goto <D.28760>; else goto <D.28761>;
          <D.28760>:
          cfg->verbose_level = 4;
          <D.28761>:
          mono_method_desc_free (desc);
        }
        goto <D.28755>;
        <D.28754>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.28642 = cfg->method;
          D.28732 = D.28642->name;
          D.28762 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
          D.25581 = __builtin_strcmp (D.28732, D.28762);
        }
        if (D.25581 == 0) goto <D.28763>; else goto <D.28764>;
        <D.28763>:
        cfg->verbose_level = 4;
        <D.28764>:
        <D.28755>:
      }
      <D.28752>:
      ip = header->code;
      D.28765 = cfg->mempool;
      D.28766 = header->max_stack;
      D.28767 = (unsigned int) D.28766;
      D.28768 = D.28767 * 16;
      D.28769 = mono_mempool_alloc0 (D.28765, D.28768);
      cfg->intvars = D.28769;
      D.28770 = cfg->verbose_level;
      if (D.28770 != 0) goto <D.28771>; else goto <D.28772>;
      <D.28771>:
      {
        char * method_name;

        method_name = mono_method_full_name (method, 1);
        D.28774 = cfg->gsharedvt;
        if (D.28774 != 0) goto <D.28775>; else goto <D.28776>;
        <D.28775>:
        iftmp.117 = "gsharedvt ";
        goto <D.28777>;
        <D.28776>:
        iftmp.117 = "";
        <D.28777>:
        D.28688 = cfg->generic_sharing_context;
        if (D.28688 != 0B) goto <D.28781>; else goto <D.28779>;
        <D.28781>:
        D.28774 = cfg->gsharedvt;
        if (D.28774 == 0) goto <D.28782>; else goto <D.28779>;
        <D.28782>:
        iftmp.118 = "gshared ";
        goto <D.28780>;
        <D.28779>:
        iftmp.118 = "";
        <D.28780>:
        monoeg_g_print ("converting %s%s%smethod %s\n", "", iftmp.117, iftmp.118, method_name);
        monoeg_g_free (method_name);
      }
      <D.28772>:
      D.28739 = cfg->opt;
      D.28783 = D.28739 & 786432;
      if (D.28783 != 0) goto <D.28784>; else goto <D.28785>;
      <D.28784>:
      D.28739 = cfg->opt;
      D.28786 = D.28739 | 2097152;
      cfg->opt = D.28786;
      <D.28785>:
      {
        static int count = 0;

        count.119 = count;
        count.120 = count.119 + 1;
        count = count.120;
      }
      D.28789 = header->clauses;
      if (D.28789 != 0B) goto <D.28790>; else goto <D.28791>;
      <D.28790>:
      cfg->globalra = 0;
      <D.28791>:
      D.28642 = cfg->method;
      D.28792 = BIT_FIELD_REF <*D.28642, 32, 160>;
      D.28793 = D.28792 & 124;
      if (D.28793 == 20) goto <D.28794>; else goto <D.28795>;
      <D.28794>:
      cfg->globalra = 0;
      <D.28795>:
      D.28642 = cfg->method;
      D.28792 = BIT_FIELD_REF <*D.28642, 32, 160>;
      D.28796 = D.28792 & 256;
      if (D.28796 != 0) goto <D.28797>; else goto <D.28798>;
      <D.28797>:
      cfg->globalra = 0;
      <D.28798>:
      D.28799 = header->code_size;
      if (D.28799 > 5000) goto <D.28800>; else goto <D.28801>;
      <D.28800>:
      cfg->globalra = 0;
      <D.28801>:
      D.28802 = mono_regstate_new ();
      cfg->rs = D.28802;
      D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.28803 = D.28677 & 4096;
      if (D.28803 != 0) goto <D.28804>; else goto <D.28805>;
      <D.28804>:
      D.28806 = cfg->rs;
      D.28806->next_vreg = 64;
      <D.28805>:
      D.28806 = cfg->rs;
      D.28807 = D.28806->next_vreg;
      D.28808 = (unsigned int) D.28807;
      cfg->next_vreg = D.28808;
      D.28739 = cfg->opt;
      D.28809 = D.28739 & 2097152;
      if (D.28809 != 0) goto <D.28810>; else goto <D.28811>;
      <D.28810>:
      cfg->enable_extended_bblocks = 0;
      <D.28811>:
      D.28642 = cfg->method;
      D.28812 = mono_compile_is_broken (cfg, D.28642, 1);
      if (D.28812 != 0) goto <D.28813>; else goto <D.28814>;
      <D.28813>:
      D.28815 = mini_get_debug_options ();
      D.28816 = D.28815->break_on_unverified;
      if (D.28816 != 0) goto <D.28817>; else goto <D.28818>;
      <D.28817>:
      raise (5);
      <D.28818>:
      D.28685 = cfg;
      return D.28685;
      <D.28814>:
      mono_compile_create_vars (cfg);
      D.28739 = cfg->opt;
      D.28819 = D.28739 & 4294443007;
      cfg->opt = D.28819;
      i = mono_method_to_ir (cfg, method_to_compile, 0B, 0B, 0B, 0B, 0B, 0, 0);
      if (i < 0) goto <D.28820>; else goto <D.28821>;
      <D.28820>:
      if (try_generic_shared != 0) goto <D.28822>; else goto <D.28823>;
      <D.28822>:
      D.28824 = cfg->exception_type;
      if (D.28824 == 11) goto <D.28825>; else goto <D.28826>;
      <D.28825>:
      if (compile_aot != 0) goto <D.28827>; else goto <D.28828>;
      <D.28827>:
      if (0 != 0) goto <D.28829>; else goto <D.28830>;
      <D.28829>:
      <D.28830>:
      D.28685 = cfg;
      return D.28685;
      <D.28828>:
      mono_destroy_compile (cfg);
      try_generic_shared = 0;
      goto restart_compile;
      <D.28826>:
      <D.28823>:
      D.28824 = cfg->exception_type;
      D.28831 = D.28824 == 11;
      D.28832 = (long int) D.28831;
      D.28833 = __builtin_expect (D.28832, 0);
      if (D.28833 != 0) goto <D.28834>; else goto <D.28835>;
      <D.28834>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5206, "cfg->exception_type != MONO_EXCEPTION_GENERIC_SHARING_FAILED");
      <D.28835>:
      if (0 != 0) goto <D.28836>; else goto <D.28837>;
      <D.28836>:
      <D.28837>:
      D.28685 = cfg;
      return D.28685;
      <D.28821>:
      D.28838 = cfg->stat_basic_blocks;
      D.28839 = (unsigned int) D.28838;
      D.28840 = cfg->num_bblocks;
      D.28841 = D.28839 + D.28840;
      D.28842 = (int) D.28841;
      cfg->stat_basic_blocks = D.28842;
      if (0 != 0) goto <D.28843>; else goto <D.28844>;
      <D.28843>:
      {
        struct MonoInst * ins;

        D.28739 = cfg->opt;
        D.28786 = D.28739 | 2097152;
        cfg->opt = D.28786;
        D.28845 = cfg->ret;
        if (D.28845 != 0B) goto <D.28846>; else goto <D.28847>;
        <D.28846>:
        D.28845 = cfg->ret;
        D.28845 = cfg->ret;
        D.28848 = D.28845->flags;
        D.28849 = D.28848 & 251;
        D.28845->flags = D.28849;
        D.28765 = cfg->mempool;
        ins = mono_mempool_alloc (D.28765, 56);
        ins->data.op[1].const_val = 0;
        D.28850 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.28850;
        ins->prev = 0B;
        D.28851 = ins->prev;
        ins->next = D.28851;
        ins->opcode = 335;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.28852 = ins->sreg3;
        ins->sreg2 = D.28852;
        D.28853 = ins->sreg2;
        ins->sreg1 = D.28853;
        D.28854 = cfg->ip;
        ins->cil_code = D.28854;
        D.28845 = cfg->ret;
        D.28855 = D.28845->dreg;
        ins->sreg1 = D.28855;
        D.28856 = cfg->bb_exit;
        D.28857 = D.28856->last_ins;
        if (D.28857 != 0B) goto <D.28858>; else goto <D.28859>;
        <D.28858>:
        D.28856 = cfg->bb_exit;
        D.28857 = D.28856->last_ins;
        D.28857->next = ins;
        D.28856 = cfg->bb_exit;
        D.28857 = D.28856->last_ins;
        ins->prev = D.28857;
        D.28856 = cfg->bb_exit;
        D.28856->last_ins = ins;
        goto <D.28860>;
        <D.28859>:
        D.28856 = cfg->bb_exit;
        D.28856 = cfg->bb_exit;
        D.28856->last_ins = ins;
        D.28857 = D.28856->last_ins;
        D.28856->code = D.28857;
        <D.28860>:
        <D.28847>:
        D.28739 = cfg->opt;
        D.28861 = D.28739 & 4294967167;
        cfg->opt = D.28861;
        D.28739 = cfg->opt;
        D.28862 = D.28739 & 4294967293;
        cfg->opt = D.28862;
      }
      <D.28844>:
      mono_liveness_handle_exception_clauses (cfg);
      mono_handle_out_of_line_bblock (cfg);
      if (1 != 0) goto <D.28863>; else goto <D.28864>;
      <D.28863>:
      mono_decompose_long_opts (cfg);
      <D.28864>:
      D.28739 = cfg->opt;
      D.28865 = D.28739 & 48;
      if (D.28865 != 0) goto <D.28866>; else goto <D.28867>;
      <D.28866>:
      mono_local_cprop (cfg);
      <D.28867>:
      D.28739 = cfg->opt;
      D.28868 = D.28739 & 2;
      if (D.28868 != 0) goto <D.28869>; else goto <D.28870>;
      <D.28869>:
      mono_optimize_branches (cfg);
      <D.28870>:
      mono_handle_global_vregs (cfg);
      D.28739 = cfg->opt;
      D.28871 = D.28739 & 64;
      if (D.28871 != 0) goto <D.28872>; else goto <D.28873>;
      <D.28872>:
      mono_local_deadce (cfg);
      <D.28873>:
      D.28739 = cfg->opt;
      D.28874 = D.28739 & 268435456;
      if (D.28874 != 0) goto <D.28875>; else goto <D.28876>;
      <D.28875>:
      mono_local_alias_analysis (cfg);
      <D.28876>:
      if (1 != 0) goto <D.28877>; else goto <D.28878>;
      <D.28877>:
      mono_if_conversion (cfg);
      <D.28878>:
      D.28739 = cfg->opt;
      D.28881 = D.28739 & 524288;
      if (D.28881 != 0) goto <D.28879>; else goto <D.28882>;
      <D.28882>:
      D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.28803 = D.28677 & 4096;
      if (D.28803 != 0) goto <D.28879>; else goto <D.28880>;
      <D.28879>:
      mono_remove_critical_edges (cfg);
      <D.28880>:
      D.28765 = cfg->mempool;
      D.28840 = cfg->num_bblocks;
      D.28883 = D.28840 + 1;
      D.28884 = D.28883 * 4;
      D.28885 = mono_mempool_alloc (D.28765, D.28884);
      cfg->bblocks = D.28885;
      D.28840 = cfg->num_bblocks;
      cfg->max_block_num = D.28840;
      dfn = 0;
      D.28886 = cfg->bb_entry;
      D.28887 = cfg->bblocks;
      df_visit (D.28886, &dfn, D.28887);
      D.28840 = cfg->num_bblocks;
      dfn.121 = dfn;
      D.28889 = dfn.121 + 1;
      D.28890 = (unsigned int) D.28889;
      if (D.28840 != D.28890) goto <D.28891>; else goto <D.28892>;
      <D.28891>:
      {
        struct MonoBasicBlock * bb;

        dfn.121 = dfn;
        D.28889 = dfn.121 + 1;
        D.28890 = (unsigned int) D.28889;
        cfg->num_bblocks = D.28890;
        bb = cfg->bb_entry;
        goto <D.25587>;
        <D.25586>:
        D.28893 = bb->flags;
        D.28894 = D.28893 & 4294967294;
        bb->flags = D.28894;
        bb = bb->next_bb;
        <D.25587>:
        if (bb != 0B) goto <D.25586>; else goto <D.25588>;
        <D.25588>:
        D.28886 = cfg->bb_entry;
        compute_reachable (D.28886);
        bb = cfg->bb_entry;
        goto <D.25590>;
        <D.25589>:
        D.28893 = bb->flags;
        D.28895 = D.28893 & 16;
        if (D.28895 != 0) goto <D.28896>; else goto <D.28897>;
        <D.28896>:
        compute_reachable (bb);
        <D.28897>:
        bb = bb->next_bb;
        <D.25590>:
        if (bb != 0B) goto <D.25589>; else goto <D.25591>;
        <D.25591>:
        bb = cfg->bb_entry;
        goto <D.25596>;
        <D.25595>:
        D.28893 = bb->flags;
        D.28898 = D.28893 & 1;
        if (D.28898 == 0) goto <D.28899>; else goto <D.28900>;
        <D.28899>:
        D.28770 = cfg->verbose_level;
        if (D.28770 > 1) goto <D.28901>; else goto <D.28902>;
        <D.28901>:
        D.28903 = bb->block_num;
        monoeg_g_print ("found unreachable code in BB%d\n", D.28903);
        <D.28902>:
        bb->last_ins = 0B;
        D.28904 = bb->last_ins;
        bb->code = D.28904;
        goto <D.25593>;
        <D.25592>:
        D.28905 = bb->out_bb;
        D.28906 = *D.28905;
        mono_unlink_bblock (cfg, bb, D.28906);
        <D.25593>:
        D.28907 = bb->out_count;
        if (D.28907 != 0) goto <D.25592>; else goto <D.25594>;
        <D.25594>:
        <D.28900>:
        bb = bb->next_bb;
        <D.25596>:
        if (bb != 0B) goto <D.25595>; else goto <D.25597>;
        <D.25597>:
        bb = cfg->bb_entry;
        goto <D.25599>;
        <D.25598>:
        D.28893 = bb->flags;
        D.28894 = D.28893 & 4294967294;
        bb->flags = D.28894;
        bb = bb->next_bb;
        <D.25599>:
        if (bb != 0B) goto <D.25598>; else goto <D.25600>;
        <D.25600>:
      }
      <D.28892>:
      D.28910 = cfg->num_varinfo;
      if (D.28910 > 2000) goto <D.28908>; else goto <D.28911>;
      <D.28911>:
      D.28840 = cfg->num_bblocks;
      if (D.28840 > 1000) goto <D.28908>; else goto <D.28909>;
      <D.28908>:
      D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.28678 = D.28677 & 64;
      if (D.28678 == 0) goto <D.28912>; else goto <D.28913>;
      <D.28912>:
      D.28739 = cfg->opt;
      D.28914 = D.28739 & 4294967119;
      cfg->opt = D.28914;
      cfg->disable_ssa = 1;
      <D.28913>:
      <D.28909>:
      D.28739 = cfg->opt;
      D.28915 = D.28739 & 8192;
      if (D.28915 != 0) goto <D.28916>; else goto <D.28917>;
      <D.28916>:
      mono_compile_dominator_info (cfg, 3);
      mono_compute_natural_loops (cfg);
      <D.28917>:
      if (parts == 1) goto <D.28918>; else goto <D.28919>;
      <D.28918>:
      if (0 != 0) goto <D.28920>; else goto <D.28921>;
      <D.28920>:
      <D.28921>:
      D.28685 = cfg;
      return D.28685;
      <D.28919>:
      D.28739 = cfg->opt;
      D.28809 = D.28739 & 2097152;
      if (D.28809 != 0) goto <D.28922>; else goto <D.28923>;
      <D.28922>:
      D.28924 = cfg->comp_done;
      D.28925 = D.28924 & 32;
      if (D.28925 == 0) goto <D.28926>; else goto <D.28927>;
      <D.28926>:
      D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.28928 = D.28677 & 2;
      if (D.28928 == 0) goto <D.28929>; else goto <D.28930>;
      <D.28929>:
      mono_ssa_compute (cfg);
      D.28770 = cfg->verbose_level;
      if (D.28770 > 1) goto <D.28931>; else goto <D.28932>;
      <D.28931>:
      print_dfn (cfg);
      <D.28932>:
      <D.28930>:
      <D.28927>:
      <D.28923>:
      if (parts == 2) goto <D.28933>; else goto <D.28934>;
      <D.28933>:
      if (0 != 0) goto <D.28935>; else goto <D.28936>;
      <D.28935>:
      <D.28936>:
      D.28685 = cfg;
      return D.28685;
      <D.28934>:
      D.28937 = BIT_FIELD_REF <*cfg, 32, 3104>;
      D.28938 = D.28937 & 48;
      if (D.28938 != 0) goto <D.28939>; else goto <D.28940>;
      <D.28939>:
      D.28924 = cfg->comp_done;
      D.28925 = D.28924 & 32;
      if (D.28925 != 0) goto <D.28941>; else goto <D.28942>;
      <D.28941>:
      mono_ssa_cprop (cfg);
      <D.28942>:
      <D.28940>:
      D.28924 = cfg->comp_done;
      D.28925 = D.28924 & 32;
      if (D.28925 != 0) goto <D.28943>; else goto <D.28944>;
      <D.28943>:
      D.28739 = cfg->opt;
      D.28881 = D.28739 & 524288;
      if (D.28881 != 0) goto <D.28945>; else goto <D.28946>;
      <D.28945>:
      mono_perform_ssapre (cfg);
      <D.28946>:
      D.28739 = cfg->opt;
      D.28871 = D.28739 & 64;
      if (D.28871 != 0) goto <D.28947>; else goto <D.28948>;
      <D.28947>:
      mono_ssa_deadce (cfg);
      deadce_has_run = 1;
      <D.28948>:
      D.28949 = cfg->flags;
      D.28950 = D.28949 & 132;
      if (D.28950 != 0) goto <D.28951>; else goto <D.28952>;
      <D.28951>:
      D.28739 = cfg->opt;
      D.28953 = D.28739 & 262144;
      if (D.28953 != 0) goto <D.28954>; else goto <D.28955>;
      <D.28954>:
      mono_perform_abc_removal (cfg);
      <D.28955>:
      <D.28952>:
      mono_ssa_remove (cfg);
      mono_local_cprop (cfg);
      mono_handle_global_vregs (cfg);
      D.28739 = cfg->opt;
      D.28871 = D.28739 & 64;
      if (D.28871 != 0) goto <D.28956>; else goto <D.28957>;
      <D.28956>:
      mono_local_deadce (cfg);
      <D.28957>:
      D.28739 = cfg->opt;
      D.28868 = D.28739 & 2;
      if (D.28868 != 0) goto <D.28958>; else goto <D.28959>;
      <D.28958>:
      {
        struct MonoBasicBlock * bb;

        mono_optimize_branches (cfg);
        D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
        D.28803 = D.28677 & 4096;
        if (D.28803 != 0) goto <D.28960>; else goto <D.28961>;
        <D.28960>:
        mono_remove_critical_edges (cfg);
        bb = cfg->bb_entry;
        goto <D.25603>;
        <D.25602>:
        bb->dfn = 0;
        bb = bb->next_bb;
        <D.25603>:
        if (bb != 0B) goto <D.25602>; else goto <D.25604>;
        <D.25604>:
        D.28765 = cfg->mempool;
        D.28840 = cfg->num_bblocks;
        D.28883 = D.28840 + 1;
        D.28884 = D.28883 * 4;
        D.28962 = mono_mempool_alloc (D.28765, D.28884);
        cfg->bblocks = D.28962;
        dfn = 0;
        D.28886 = cfg->bb_entry;
        D.28887 = cfg->bblocks;
        df_visit (D.28886, &dfn, D.28887);
        dfn.121 = dfn;
        D.28889 = dfn.121 + 1;
        D.28890 = (unsigned int) D.28889;
        cfg->num_bblocks = D.28890;
        <D.28961>:
      }
      <D.28959>:
      <D.28944>:
      if (0 != 0) goto <D.28963>; else goto <D.28964>;
      <D.28963>:
      mono_ssa_loop_invariant_code_motion (cfg);
      D.28739 = cfg->opt;
      D.28953 = D.28739 & 262144;
      if (D.28953 != 0) goto <D.28965>; else goto <D.28966>;
      <D.28965>:
      mono_perform_abc_removal (cfg);
      <D.28966>:
      <D.28964>:
      if (parts == 3) goto <D.28967>; else goto <D.28968>;
      <D.28967>:
      if (0 != 0) goto <D.28969>; else goto <D.28970>;
      <D.28969>:
      <D.28970>:
      D.28685 = cfg;
      return D.28685;
      <D.28968>:
      if (0 != 0) goto <D.28971>; else goto <D.28972>;
      <D.28971>:
      mono_decompose_vtype_opts_llvm (cfg);
      goto <D.28973>;
      <D.28972>:
      mono_decompose_vtype_opts (cfg);
      <D.28973>:
      D.28949 = cfg->flags;
      D.28974 = D.28949 & 256;
      if (D.28974 != 0) goto <D.28975>; else goto <D.28976>;
      <D.28975>:
      mono_decompose_array_access_opts (cfg);
      <D.28976>:
      D.28977 = cfg->got_var;
      if (D.28977 != 0B) goto <D.28978>; else goto <D.28979>;
      <D.28978>:
      {
        struct GList * regs;
        int got_reg;

        D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
        D.28980 = D.28677 & 512;
        D.28981 = D.28980 == 0;
        D.28982 = (long int) D.28981;
        D.28983 = __builtin_expect (D.28982, 0);
        if (D.28983 != 0) goto <D.28984>; else goto <D.28985>;
        <D.28984>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5460, "cfg->got_var_allocated");
        <D.28985>:
        regs = mono_arch_get_global_int_regs (cfg);
        D.28986 = regs == 0B;
        D.28987 = (long int) D.28986;
        D.28988 = __builtin_expect (D.28987, 0);
        if (D.28988 != 0) goto <D.28989>; else goto <D.28990>;
        <D.28989>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5473, "regs");
        <D.28990>:
        D.28991 = regs->data;
        got_reg = (int) D.28991;
        monoeg_g_list_free (regs);
        D.28977 = cfg->got_var;
        D.28977->opcode = 366;
        D.28977 = cfg->got_var;
        D.28977->dreg = got_reg;
        D.28992 = cfg->used_int_regs;
        D.28993 = (signed int) D.28992;
        D.28977 = cfg->got_var;
        D.28994 = D.28977->dreg;
        D.28995 = 1 << D.28994;
        D.28996 = (signed int) D.28995;
        D.28997 = D.28993 | D.28996;
        D.28998 = (unsigned int) D.28997;
        cfg->used_int_regs = D.28998;
      }
      <D.28979>:
      mono_liveness_handle_exception_clauses (cfg);
      D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.28803 = D.28677 & 4096;
      if (D.28803 != 0) goto <D.28999>; else goto <D.29000>;
      <D.28999>:
      {
        struct MonoBasicBlock * bb;

        bb = cfg->bb_entry;
        goto <D.25609>;
        <D.25608>:
        mono_arch_lowering_pass (cfg, bb);
        bb = bb->next_bb;
        <D.25609>:
        if (bb != 0B) goto <D.25608>; else goto <D.25610>;
        <D.25610>:
        mono_global_regalloc (cfg);
      }
      <D.29000>:
      D.28739 = cfg->opt;
      D.29001 = D.28739 & 128;
      if (D.29001 != 0) goto <D.29002>; else goto <D.29003>;
      <D.29002>:
      D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.28803 = D.28677 & 4096;
      if (D.28803 == 0) goto <D.29004>; else goto <D.29005>;
      <D.29004>:
      {
        struct GList * vars;
        struct GList * regs;
        struct GList * l;

        D.28924 = cfg->comp_done;
        D.29006 = D.28924 & 4294967279;
        cfg->comp_done = D.29006;
        D.28924 = cfg->comp_done;
        D.29007 = D.28924 & 16;
        if (D.29007 == 0) goto <D.29008>; else goto <D.29009>;
        <D.29008>:
        mono_analyze_liveness (cfg);
        <D.29009>:
        vars = mono_arch_get_allocatable_int_vars (cfg);
        if (vars != 0B) goto <D.29010>; else goto <D.29011>;
        <D.29010>:
        regs = mono_arch_get_global_int_regs (cfg);
        D.28977 = cfg->got_var;
        if (D.28977 != 0B) goto <D.29012>; else goto <D.29013>;
        <D.29012>:
        l = regs;
        goto <D.25616>;
        <D.25615>:
        D.29014 = l->data;
        D.29015 = (unsigned int) D.29014;
        D.28977 = cfg->got_var;
        D.28994 = D.28977->dreg;
        D.29016 = (unsigned int) D.28994;
        if (D.29015 == D.29016) goto <D.29017>; else goto <D.29018>;
        <D.29017>:
        regs = monoeg_g_list_delete_link (regs, l);
        goto <D.25614>;
        <D.29018>:
        l = l->next;
        <D.25616>:
        if (l != 0B) goto <D.25615>; else goto <D.25614>;
        <D.25614>:
        <D.29013>:
        D.29019 = &cfg->used_int_regs;
        mono_linear_scan (cfg, vars, regs, D.29019);
        <D.29011>:
      }
      <D.29005>:
      <D.29003>:
      D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.28803 = D.28677 & 4096;
      if (D.28803 == 0) goto <D.29020>; else goto <D.29021>;
      <D.29020>:
      mono_arch_allocate_vars (cfg);
      D.28824 = cfg->exception_type;
      if (D.28824 != 0) goto <D.29022>; else goto <D.29023>;
      <D.29022>:
      D.28685 = cfg;
      return D.28685;
      <D.29023>:
      <D.29021>:
      {
        struct MonoBasicBlock * bb;
        gboolean need_local_opts;

        try
          {
            D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
            D.28803 = D.28677 & 4096;
            if (D.28803 == 0) goto <D.29024>; else goto <D.29025>;
            <D.29024>:
            mono_spill_global_vars (cfg, &need_local_opts);
            need_local_opts.122 = need_local_opts;
            if (need_local_opts.122 != 0) goto <D.29026>; else goto <D.29029>;
            <D.29029>:
            D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
            D.28678 = D.28677 & 64;
            if (D.28678 != 0) goto <D.29026>; else goto <D.29027>;
            <D.29026>:
            mono_local_cprop (cfg);
            D.28739 = cfg->opt;
            D.28871 = D.28739 & 64;
            if (D.28871 != 0) goto <D.29030>; else goto <D.29031>;
            <D.29030>:
            mono_local_deadce (cfg);
            <D.29031>:
            <D.29027>:
            <D.29025>:
            bb = cfg->bb_entry;
            goto <D.25622>;
            <D.25621>:
            D.29034 = bb->last_ins;
            if (D.29034 != 0B) goto <D.29035>; else goto <D.29036>;
            <D.29035>:
            D.29034 = bb->last_ins;
            D.29037 = D.29034->opcode;
            D.29038 = D.29037 + 64985;
            if (D.29038 <= 9) goto <D.29032>; else goto <D.29039>;
            <D.29039>:
            D.29034 = bb->last_ins;
            D.29037 = D.29034->opcode;
            D.29040 = D.29037 + 64878;
            if (D.29040 <= 9) goto <D.29032>; else goto <D.29041>;
            <D.29041>:
            D.29034 = bb->last_ins;
            D.29037 = D.29034->opcode;
            D.29042 = D.29037 + 64888;
            if (D.29042 <= 9) goto <D.29032>; else goto <D.29033>;
            <D.29032>:
            D.29034 = bb->last_ins;
            D.29043 = D.29034->data.op[1].many_blocks;
            D.29044 = D.29043 + 4;
            D.29045 = *D.29044;
            if (D.29045 != 0B) goto <D.29046>; else goto <D.29047>;
            <D.29046>:
            D.29048 = bb->next_bb;
            D.29034 = bb->last_ins;
            D.29043 = D.29034->data.op[1].many_blocks;
            D.29044 = D.29043 + 4;
            D.29045 = *D.29044;
            if (D.29048 != D.29045) goto <D.29049>; else goto <D.29050>;
            <D.29049>:
            D.29034 = bb->last_ins;
            D.29037 = D.29034->opcode;
            D.29038 = D.29037 + 64985;
            if (D.29038 <= 9) goto <D.29051>; else goto <D.29055>;
            <D.29055>:
            D.29034 = bb->last_ins;
            D.29037 = D.29034->opcode;
            D.29040 = D.29037 + 64878;
            if (D.29040 <= 9) goto <D.29051>; else goto <D.29056>;
            <D.29056>:
            D.29034 = bb->last_ins;
            D.29037 = D.29034->opcode;
            D.29042 = D.29037 + 64888;
            if (D.29042 <= 9) goto <D.29051>; else goto <D.29052>;
            <D.29051>:
            D.29034 = bb->last_ins;
            D.29037 = D.29034->opcode;
            D.29040 = D.29037 + 64878;
            if (D.29040 > 9) goto <D.29057>; else goto <D.29052>;
            <D.29057>:
            D.29034 = bb->last_ins;
            D.29058 = D.29034->data.op[0].src;
            if (D.29058 == 0B) goto <D.29053>; else goto <D.29059>;
            <D.29059>:
            D.29034 = bb->last_ins;
            D.29058 = D.29034->data.op[0].src;
            D.29060 = D.29058->data.op[0].src;
            D.29061 = D.29060->type;
            if (D.29061 != 4) goto <D.29053>; else goto <D.29052>;
            <D.29053>:
            D.29048 = bb->next_bb;
            D.29034 = bb->last_ins;
            D.29043 = D.29034->data.op[1].many_blocks;
            D.29062 = *D.29043;
            if (D.29048 == D.29062) goto <D.29063>; else goto <D.29052>;
            <D.29063>:
            {
              struct MonoBasicBlock * tmp;

              D.29034 = bb->last_ins;
              D.29043 = D.29034->data.op[1].many_blocks;
              tmp = *D.29043;
              D.29034 = bb->last_ins;
              D.29043 = D.29034->data.op[1].many_blocks;
              D.29034 = bb->last_ins;
              D.29043 = D.29034->data.op[1].many_blocks;
              D.29064 = MEM[(struct MonoBasicBlock * *)D.29043 + 4B];
              *D.29043 = D.29064;
              D.29034 = bb->last_ins;
              D.29043 = D.29034->data.op[1].many_blocks;
              D.29044 = D.29043 + 4;
              *D.29044 = tmp;
              D.29034 = bb->last_ins;
              D.29034 = bb->last_ins;
              D.29037 = D.29034->opcode;
              D.29065 = (unsigned int) D.29037;
              D.29066 = mono_reverse_branch_op (D.29065);
              D.29067 = (short unsigned int) D.29066;
              D.29034->opcode = D.29067;
            }
            goto <D.29054>;
            <D.29052>:
            {
              struct MonoInst * inst;

              D.28765 = cfg->mempool;
              inst = mono_mempool_alloc0 (D.28765, 56);
              inst->opcode = 442;
              D.29034 = bb->last_ins;
              D.29043 = D.29034->data.op[1].many_blocks;
              D.29064 = MEM[(struct MonoBasicBlock * *)D.29043 + 4B];
              inst->data.op[0].target_block = D.29064;
              mono_bblock_add_inst (bb, inst);
            }
            <D.29054>:
            <D.29050>:
            <D.29047>:
            <D.29033>:
            <D.29036>:
            bb = bb->next_bb;
            <D.25622>:
            if (bb != 0B) goto <D.25621>; else goto <D.25623>;
            <D.25623>:
            D.28770 = cfg->verbose_level;
            if (D.28770 > 3) goto <D.29068>; else goto <D.29069>;
            <D.29068>:
            D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
            D.28803 = D.28677 & 4096;
            if (D.28803 == 0) goto <D.29070>; else goto <D.29071>;
            <D.29070>:
            bb = cfg->bb_entry;
            goto <D.25630>;
            <D.25629>:
            {
              struct MonoInst * tree;

              tree = bb->code;
              D.29072 = bb->block_num;
              monoeg_g_print ("DUMP BLOCK %d:\n", D.29072);
              if (tree == 0B) goto <D.29073>; else goto <D.29074>;
              <D.29073>:
              // predicted unlikely by continue predictor.
              goto <D.25625>;
              <D.29074>:
              goto <D.25627>;
              <D.25626>:
              mono_print_ins_index (-1, tree);
              tree = tree->next;
              <D.25627>:
              if (tree != 0B) goto <D.25626>; else goto <D.25628>;
              <D.25628>:
            }
            <D.25625>:
            bb = bb->next_bb;
            <D.25630>:
            if (bb != 0B) goto <D.25629>; else goto <D.25631>;
            <D.25631>:
            <D.29071>:
            <D.29069>:
            bb = cfg->bb_entry;
            goto <D.25633>;
            <D.25632>:
            D.29075 = cfg->next_vreg;
            bb->max_vreg = D.29075;
            bb = bb->next_bb;
            <D.25633>:
            if (bb != 0B) goto <D.25632>; else goto <D.25634>;
            <D.25634>:
          }
        finally
          {
            need_local_opts = {CLOBBER};
          }
      }
      if (0 != 0) goto <D.29076>; else goto <D.29077>;
      <D.29076>:
      goto <D.29078>;
      <D.29077>:
      mono_codegen (cfg);
      <D.29078>:
      if (0 != 0) goto <D.29079>; else goto <D.29080>;
      <D.29079>:
      InterlockedIncrement (&mono_jit_stats.methods_with_llvm);
      goto <D.29081>;
      <D.29080>:
      InterlockedIncrement (&mono_jit_stats.methods_without_llvm);
      <D.29081>:
      D.29082 = create_jit_info (cfg, method_to_compile);
      cfg->jit_info = D.29082;
      D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.28678 = D.28677 & 64;
      if (D.28678 == 0) goto <D.29083>; else goto <D.29084>;
      <D.29083>:
      mono_save_xdebug_info (cfg);
      <D.29084>:
      mini_gc_create_gc_map (cfg);
      mono_save_seq_point_info (cfg);
      D.28770 = cfg->verbose_level;
      if (D.28770 > 1) goto <D.29085>; else goto <D.29086>;
      <D.29085>:
      {
        char * id;

        D.28642 = cfg->method;
        id = mono_method_full_name (D.28642, 0);
        D.29087 = cfg->native_code;
        D.29088 = cfg->code_len;
        D.29089 = (int) D.29088;
        D.29090 = id + 3;
        mono_disassemble_code (cfg, D.29087, D.29089, D.29090);
        monoeg_g_free (id);
      }
      <D.29086>:
      D.28677 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.28678 = D.28677 & 64;
      if (D.28678 == 0) goto <D.29091>; else goto <D.29092>;
      <D.29091>:
      {
        int ret;

        D.29093 = cfg->domain;
        D.29094 = &D.29093->lock.mutex;
        ret = pthread_mutex_lock (D.29094);
        if (ret != 0) goto <D.29095>; else goto <D.29096>;
        <D.29095>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29096>:
        D.29097 = ret != 0;
        D.29098 = (long int) D.29097;
        D.29099 = __builtin_expect (D.29098, 0);
        if (D.29099 != 0) goto <D.29100>; else goto <D.29101>;
        <D.29100>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5653, "ret == 0");
        <D.29101>:
      }
      D.29093 = cfg->domain;
      D.29102 = cfg->jit_info;
      mono_jit_info_table_add (D.29093, D.29102);
      D.28642 = cfg->method;
      D.28792 = BIT_FIELD_REF <*D.28642, 32, 160>;
      D.29103 = D.28792 & 512;
      if (D.29103 != 0) goto <D.29104>; else goto <D.29105>;
      <D.29104>:
      D.29093 = cfg->domain;
      D.28642 = cfg->method;
      D.29106 = mono_dynamic_code_hash_lookup (D.29093, D.28642);
      D.29102 = cfg->jit_info;
      D.29106->ji = D.29102;
      <D.29105>:
      {
        int ret;

        D.29093 = cfg->domain;
        D.29094 = &D.29093->lock.mutex;
        ret = pthread_mutex_unlock (D.29094);
        if (ret != 0) goto <D.29107>; else goto <D.29108>;
        <D.29107>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29108>:
        D.29109 = ret != 0;
        D.29110 = (long int) D.29109;
        D.29111 = __builtin_expect (D.29110, 0);
        if (D.29111 != 0) goto <D.29112>; else goto <D.29113>;
        <D.29112>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5658, "ret == 0");
        <D.29113>:
      }
      <D.29092>:
      mono_perfcounters.123 = mono_perfcounters;
      D.29115 = mono_perfcounters.123->jit_methods;
      D.29116 = D.29115 + 1;
      mono_perfcounters.123->jit_methods = D.29116;
      mono_perfcounters.123 = mono_perfcounters;
      mono_perfcounters.123 = mono_perfcounters;
      D.29117 = mono_perfcounters.123->jit_bytes;
      D.28799 = header->code_size;
      D.29118 = D.29117 + D.28799;
      mono_perfcounters.123->jit_bytes = D.29118;
      D.29119 = mono_jit_stats.allocated_code_size;
      D.29120 = (unsigned int) D.29119;
      D.29088 = cfg->code_len;
      D.29121 = D.29120 + D.29088;
      D.29122 = (int) D.29121;
      mono_jit_stats.allocated_code_size = D.29122;
      D.29088 = cfg->code_len;
      code_size_ratio = (int) D.29088;
      D.29123 = mono_jit_stats.biggest_method_size;
      if (D.29123 < code_size_ratio) goto <D.29124>; else goto <D.29125>;
      <D.29124>:
      D.29126 = mono_jit_stats.enabled;
      if (D.29126 != 0) goto <D.29127>; else goto <D.29128>;
      <D.29127>:
      mono_jit_stats.biggest_method_size = code_size_ratio;
      D.29129 = mono_jit_stats.biggest_method;
      monoeg_g_free (D.29129);
      D.28578 = method->klass;
      D.29130 = D.28578->name;
      D.29131 = method->name;
      D.29132 = monoeg_g_strdup_printf ("%s::%s)", D.29130, D.29131);
      mono_jit_stats.biggest_method = D.29132;
      <D.29128>:
      <D.29125>:
      D.29133 = code_size_ratio * 100;
      D.29134 = (unsigned int) D.29133;
      D.28799 = header->code_size;
      D.29135 = D.29134 / D.28799;
      code_size_ratio = (int) D.29135;
      D.29136 = mono_jit_stats.max_code_size_ratio;
      if (D.29136 < code_size_ratio) goto <D.29137>; else goto <D.29138>;
      <D.29137>:
      D.29126 = mono_jit_stats.enabled;
      if (D.29126 != 0) goto <D.29139>; else goto <D.29140>;
      <D.29139>:
      mono_jit_stats.max_code_size_ratio = code_size_ratio;
      D.29141 = mono_jit_stats.max_ratio_method;
      monoeg_g_free (D.29141);
      D.28578 = method->klass;
      D.29130 = D.28578->name;
      D.29131 = method->name;
      D.29142 = monoeg_g_strdup_printf ("%s::%s)", D.29130, D.29131);
      mono_jit_stats.max_ratio_method = D.29142;
      <D.29140>:
      <D.29138>:
      D.29143 = mono_jit_stats.native_code_size;
      D.29144 = (unsigned int) D.29143;
      D.29088 = cfg->code_len;
      D.29145 = D.29144 + D.29088;
      D.29146 = (int) D.29145;
      mono_jit_stats.native_code_size = D.29146;
      if (0 != 0) goto <D.29147>; else goto <D.29148>;
      <D.29147>:
      <D.29148>:
      D.28685 = cfg;
      return D.28685;
    }
  finally
    {
      err = {CLOBBER};
      dfn = {CLOBBER};
    }
}


is_gsharedvt_method (struct MonoMethod * method)
{
  unsigned int D.29151;
  unsigned int D.29152;
  gboolean D.29155;
  struct MonoType * D.29158;
  int D.29159;
  <unnamed-unsigned:22> D.29162;
  int D.29163;
  int D.29166;
  struct MonoGenericContext * context;
  struct MonoGenericInst * inst;
  int i;

  D.29151 = BIT_FIELD_REF <*method, 32, 160>;
  D.29152 = D.29151 & 4096;
  if (D.29152 == 0) goto <D.29153>; else goto <D.29154>;
  <D.29153>:
  D.29155 = 0;
  return D.29155;
  <D.29154>:
  context = mono_method_get_context (method);
  inst = context->class_inst;
  if (inst != 0B) goto <D.29156>; else goto <D.29157>;
  <D.29156>:
  i = 0;
  goto <D.25490>;
  <D.25489>:
  D.29158 = inst->type_argv[i];
  D.29159 = is_gsharedvt_type (D.29158);
  if (D.29159 != 0) goto <D.29160>; else goto <D.29161>;
  <D.29160>:
  D.29155 = 1;
  return D.29155;
  <D.29161>:
  i = i + 1;
  <D.25490>:
  D.29162 = inst->type_argc;
  D.29163 = (int) D.29162;
  if (D.29163 > i) goto <D.25489>; else goto <D.25491>;
  <D.25491>:
  <D.29157>:
  inst = context->method_inst;
  if (inst != 0B) goto <D.29164>; else goto <D.29165>;
  <D.29164>:
  i = 0;
  goto <D.25493>;
  <D.25492>:
  D.29158 = inst->type_argv[i];
  D.29166 = is_gsharedvt_type (D.29158);
  if (D.29166 != 0) goto <D.29167>; else goto <D.29168>;
  <D.29167>:
  D.29155 = 1;
  return D.29155;
  <D.29168>:
  i = i + 1;
  <D.25493>:
  D.29162 = inst->type_argc;
  D.29163 = (int) D.29162;
  if (D.29163 > i) goto <D.25492>; else goto <D.25494>;
  <D.25494>:
  <D.29165>:
  D.29155 = 0;
  return D.29155;
}


is_gsharedvt_type (struct MonoType * t)
{
  gboolean D.29170;
  int iftmp.124;
  unsigned char D.29175;
  struct MonoGenericParam * D.29177;
  short unsigned int D.29178;

  D.29175 = t->type;
  if (D.29175 == 19) goto <D.29172>; else goto <D.29176>;
  <D.29176>:
  D.29175 = t->type;
  if (D.29175 == 30) goto <D.29172>; else goto <D.29173>;
  <D.29172>:
  D.29177 = t->data.generic_param;
  D.29178 = D.29177->serial;
  if (D.29178 == 1) goto <D.29179>; else goto <D.29173>;
  <D.29179>:
  iftmp.124 = 1;
  goto <D.29174>;
  <D.29173>:
  iftmp.124 = 0;
  <D.29174>:
  D.29170 = iftmp.124;
  return D.29170;
}


is_open_method (struct MonoMethod * method)
{
  unsigned int D.29181;
  unsigned int D.29182;
  gboolean D.29185;
  struct MonoGenericInst * D.29186;
  unsigned int D.29189;
  unsigned int D.29190;
  struct MonoGenericInst * D.29193;
  unsigned int D.29196;
  unsigned int D.29197;
  struct MonoGenericContext * context;

  D.29181 = BIT_FIELD_REF <*method, 32, 160>;
  D.29182 = D.29181 & 4096;
  if (D.29182 == 0) goto <D.29183>; else goto <D.29184>;
  <D.29183>:
  D.29185 = 0;
  return D.29185;
  <D.29184>:
  context = mono_method_get_context (method);
  D.29186 = context->class_inst;
  if (D.29186 != 0B) goto <D.29187>; else goto <D.29188>;
  <D.29187>:
  D.29186 = context->class_inst;
  D.29189 = BIT_FIELD_REF <*D.29186, 32, 32>;
  D.29190 = D.29189 & 4194304;
  if (D.29190 != 0) goto <D.29191>; else goto <D.29192>;
  <D.29191>:
  D.29185 = 1;
  return D.29185;
  <D.29192>:
  <D.29188>:
  D.29193 = context->method_inst;
  if (D.29193 != 0B) goto <D.29194>; else goto <D.29195>;
  <D.29194>:
  D.29193 = context->method_inst;
  D.29196 = BIT_FIELD_REF <*D.29193, 32, 32>;
  D.29197 = D.29196 & 4194304;
  if (D.29197 != 0) goto <D.29198>; else goto <D.29199>;
  <D.29198>:
  D.29185 = 1;
  return D.29185;
  <D.29199>:
  <D.29195>:
  D.29185 = 0;
  return D.29185;
}


mono_compile_create_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.29201;
  struct MonoType * D.29202;
  int D.29203;
  struct MonoInst * D.29206;
  struct MonoInst * D.29207;
  unsigned char D.29208;
  unsigned char D.29209;
  unsigned int D.29210;
  struct MonoMemPool * D.29213;
  short unsigned int D.29214;
  int D.29215;
  <unnamed-unsigned:1> D.29216;
  int D.29217;
  int D.29218;
  unsigned int D.29219;
  unsigned int D.29220;
  void * D.29221;
  unsigned int D.29222;
  unsigned int D.29223;
  struct MonoInst * * D.29226;
  struct MonoClass * D.29227;
  struct MonoType * D.29228;
  struct MonoInst * D.29229;
  int D.29230;
  unsigned int D.29231;
  unsigned int D.29232;
  struct MonoInst * * D.29233;
  struct MonoType * D.29234;
  struct MonoInst * D.29235;
  struct MonoInst * D.29242;
  struct MonoInst * D.29243;
  unsigned int D.29244;
  short unsigned int D.29245;
  unsigned int D.29246;
  unsigned int D.29247;
  void * D.29248;
  struct MonoInst * * D.29251;
  unsigned int i.125;
  unsigned int D.29253;
  struct MonoInst * * D.29254;
  struct MonoType * D.29255;
  struct MonoInst * D.29256;
  int D.29257;
  unsigned int D.29260;
  unsigned int D.29261;
  unsigned int D.29264;
  unsigned int D.29265;
  struct MonoClass * D.29268;
  struct MonoType * D.29269;
  unsigned char D.29270;
  unsigned char D.29271;
  unsigned char D.29272;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  int i;

  header = cfg->header;
  D.29201 = cfg->method;
  sig = mono_method_signature (D.29201);
  D.29202 = sig->ret;
  D.29203 = mono_type_is_void (D.29202);
  if (D.29203 == 0) goto <D.29204>; else goto <D.29205>;
  <D.29204>:
  D.29202 = sig->ret;
  D.29206 = mono_compile_create_var (cfg, D.29202, 330);
  cfg->ret = D.29206;
  D.29207 = cfg->ret;
  D.29207 = cfg->ret;
  D.29208 = D.29207->flags;
  D.29209 = D.29208 | 4;
  D.29207->flags = D.29209;
  <D.29205>:
  D.29210 = cfg->verbose_level;
  if (D.29210 > 2) goto <D.29211>; else goto <D.29212>;
  <D.29211>:
  monoeg_g_print ("creating vars\n");
  <D.29212>:
  D.29213 = cfg->mempool;
  D.29214 = sig->param_count;
  D.29215 = (int) D.29214;
  D.29216 = sig->hasthis;
  D.29217 = (int) D.29216;
  D.29218 = D.29215 + D.29217;
  D.29219 = (unsigned int) D.29218;
  D.29220 = D.29219 * 4;
  D.29221 = mono_mempool_alloc0 (D.29213, D.29220);
  cfg->args = D.29221;
  D.29222 = BIT_FIELD_REF <*sig, 32, 64>;
  D.29223 = D.29222 & 4194304;
  if (D.29223 != 0) goto <D.29224>; else goto <D.29225>;
  <D.29224>:
  D.29226 = cfg->args;
  D.29201 = cfg->method;
  D.29227 = D.29201->klass;
  D.29228 = &D.29227->this_arg;
  D.29229 = mono_compile_create_var (cfg, D.29228, 330);
  *D.29226 = D.29229;
  <D.29225>:
  i = 0;
  goto <D.25246>;
  <D.25245>:
  D.29226 = cfg->args;
  D.29216 = sig->hasthis;
  D.29217 = (int) D.29216;
  D.29230 = D.29217 + i;
  D.29231 = (unsigned int) D.29230;
  D.29232 = D.29231 * 4;
  D.29233 = D.29226 + D.29232;
  D.29234 = sig->params[i];
  D.29235 = mono_compile_create_var (cfg, D.29234, 330);
  *D.29233 = D.29235;
  i = i + 1;
  <D.25246>:
  D.29214 = sig->param_count;
  D.29215 = (int) D.29214;
  if (D.29215 > i) goto <D.25245>; else goto <D.25247>;
  <D.25247>:
  D.29210 = cfg->verbose_level;
  if (D.29210 > 2) goto <D.29236>; else goto <D.29237>;
  <D.29236>:
  D.29207 = cfg->ret;
  if (D.29207 != 0B) goto <D.29238>; else goto <D.29239>;
  <D.29238>:
  printf ("\treturn : ");
  D.29207 = cfg->ret;
  mono_print_ins (D.29207);
  <D.29239>:
  D.29222 = BIT_FIELD_REF <*sig, 32, 64>;
  D.29223 = D.29222 & 4194304;
  if (D.29223 != 0) goto <D.29240>; else goto <D.29241>;
  <D.29240>:
  printf ("\tthis: ");
  D.29226 = cfg->args;
  D.29242 = *D.29226;
  mono_print_ins (D.29242);
  <D.29241>:
  i = 0;
  goto <D.25249>;
  <D.25248>:
  printf ("\targ [%d]: ", i);
  D.29226 = cfg->args;
  D.29216 = sig->hasthis;
  D.29217 = (int) D.29216;
  D.29230 = D.29217 + i;
  D.29231 = (unsigned int) D.29230;
  D.29232 = D.29231 * 4;
  D.29233 = D.29226 + D.29232;
  D.29243 = *D.29233;
  mono_print_ins (D.29243);
  i = i + 1;
  <D.25249>:
  D.29214 = sig->param_count;
  D.29215 = (int) D.29214;
  if (D.29215 > i) goto <D.25248>; else goto <D.25250>;
  <D.25250>:
  <D.29237>:
  D.29244 = cfg->num_varinfo;
  cfg->locals_start = D.29244;
  D.29213 = cfg->mempool;
  D.29245 = header->num_locals;
  D.29246 = (unsigned int) D.29245;
  D.29247 = D.29246 * 4;
  D.29248 = mono_mempool_alloc0 (D.29213, D.29247);
  cfg->locals = D.29248;
  D.29210 = cfg->verbose_level;
  if (D.29210 > 2) goto <D.29249>; else goto <D.29250>;
  <D.29249>:
  monoeg_g_print ("creating locals\n");
  <D.29250>:
  i = 0;
  goto <D.25252>;
  <D.25251>:
  D.29251 = cfg->locals;
  i.125 = (unsigned int) i;
  D.29253 = i.125 * 4;
  D.29254 = D.29251 + D.29253;
  D.29255 = header->locals[i];
  D.29256 = mono_compile_create_var (cfg, D.29255, 329);
  *D.29254 = D.29256;
  i = i + 1;
  <D.25252>:
  D.29245 = header->num_locals;
  D.29257 = (int) D.29245;
  if (D.29257 > i) goto <D.25251>; else goto <D.25253>;
  <D.25253>:
  D.29210 = cfg->verbose_level;
  if (D.29210 > 2) goto <D.29258>; else goto <D.29259>;
  <D.29258>:
  monoeg_g_print ("locals done\n");
  <D.29259>:
  mono_arch_create_vars (cfg);
  D.29201 = cfg->method;
  D.29260 = BIT_FIELD_REF <*D.29201, 32, 160>;
  D.29261 = D.29260 & 256;
  if (D.29261 != 0) goto <D.29262>; else goto <D.29263>;
  <D.29262>:
  D.29264 = BIT_FIELD_REF <*cfg, 32, 3392>;
  D.29265 = D.29264 & 33554432;
  if (D.29265 != 0) goto <D.29266>; else goto <D.29267>;
  <D.29266>:
  {
    struct MonoInst * lmf_var;

    D.29268 = mono_defaults.int_class;
    D.29269 = &D.29268->byval_arg;
    lmf_var = mono_compile_create_var (cfg, D.29269, 329);
    D.29270 = lmf_var->flags;
    D.29271 = D.29270 | 4;
    lmf_var->flags = D.29271;
    D.29270 = lmf_var->flags;
    D.29272 = D.29270 | 32;
    lmf_var->flags = D.29272;
    cfg->lmf_var = lmf_var;
  }
  <D.29267>:
  <D.29263>:
}


mono_handle_out_of_line_bblock (struct MonoCompile * cfg)
{
  struct MonoBasicBlock * D.29273;
  unsigned int D.29276;
  unsigned int D.29277;
  struct MonoInst * D.29280;
  short unsigned int D.29283;
  short unsigned int D.29284;
  short unsigned int D.29287;
  short unsigned int D.29290;
  struct MonoMemPool * D.29299;
  int D.29300;
  struct MonoInst * D.29301;
  int D.29302;
  int D.29303;
  const unsigned char * D.29304;
  struct MonoBasicBlock * bb;

  bb = cfg->bb_entry;
  goto <D.25382>;
  <D.25381>:
  D.29273 = bb->next_bb;
  if (D.29273 != 0B) goto <D.29274>; else goto <D.29275>;
  <D.29274>:
  D.29273 = bb->next_bb;
  D.29276 = BIT_FIELD_REF <*D.29273, 32, 896>;
  D.29277 = D.29276 & 65536;
  if (D.29277 != 0) goto <D.29278>; else goto <D.29279>;
  <D.29278>:
  D.29280 = bb->last_ins;
  if (D.29280 != 0B) goto <D.29281>; else goto <D.29282>;
  <D.29281>:
  D.29280 = bb->last_ins;
  D.29283 = D.29280->opcode;
  D.29284 = D.29283 + 64985;
  if (D.29284 > 9) goto <D.29285>; else goto <D.29286>;
  <D.29285>:
  D.29280 = bb->last_ins;
  D.29283 = D.29280->opcode;
  D.29287 = D.29283 + 64878;
  if (D.29287 > 9) goto <D.29288>; else goto <D.29289>;
  <D.29288>:
  D.29280 = bb->last_ins;
  D.29283 = D.29280->opcode;
  D.29290 = D.29283 + 64888;
  if (D.29290 > 9) goto <D.29291>; else goto <D.29292>;
  <D.29291>:
  D.29280 = bb->last_ins;
  D.29283 = D.29280->opcode;
  if (D.29283 != 442) goto <D.29293>; else goto <D.29294>;
  <D.29293>:
  D.29280 = bb->last_ins;
  D.29283 = D.29280->opcode;
  if (D.29283 != 759) goto <D.29295>; else goto <D.29296>;
  <D.29295>:
  D.29280 = bb->last_ins;
  D.29283 = D.29280->opcode;
  if (D.29283 != 370) goto <D.29297>; else goto <D.29298>;
  <D.29297>:
  {
    struct MonoInst * ins;

    D.29299 = cfg->mempool;
    ins = mono_mempool_alloc (D.29299, 56);
    ins->data.op[1].const_val = 0;
    D.29300 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.29300;
    ins->prev = 0B;
    D.29301 = ins->prev;
    ins->next = D.29301;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.29302 = ins->sreg3;
    ins->sreg2 = D.29302;
    D.29303 = ins->sreg2;
    ins->sreg1 = D.29303;
    D.29304 = cfg->ip;
    ins->cil_code = D.29304;
    D.29280 = bb->last_ins;
    if (D.29280 != 0B) goto <D.29305>; else goto <D.29306>;
    <D.29305>:
    D.29280 = bb->last_ins;
    D.29280->next = ins;
    D.29280 = bb->last_ins;
    ins->prev = D.29280;
    bb->last_ins = ins;
    goto <D.29307>;
    <D.29306>:
    bb->last_ins = ins;
    D.29280 = bb->last_ins;
    bb->code = D.29280;
    <D.29307>:
    D.29273 = bb->next_bb;
    ins->data.op[0].target_block = D.29273;
  }
  <D.29298>:
  <D.29296>:
  <D.29294>:
  <D.29292>:
  <D.29289>:
  <D.29286>:
  <D.29282>:
  <D.29279>:
  <D.29275>:
  bb = bb->next_bb;
  <D.25382>:
  if (bb != 0B) goto <D.25381>; else goto <D.25383>;
  <D.25383>:
}


compute_reachable (struct MonoBasicBlock * bb)
{
  unsigned int D.29308;
  unsigned int D.29309;
  unsigned int D.29312;
  struct MonoBasicBlock * * D.29313;
  unsigned int i.126;
  unsigned int D.29315;
  struct MonoBasicBlock * * D.29316;
  struct MonoBasicBlock * D.29317;
  short int D.29318;
  int D.29319;
  int i;

  D.29308 = bb->flags;
  D.29309 = D.29308 & 1;
  if (D.29309 == 0) goto <D.29310>; else goto <D.29311>;
  <D.29310>:
  D.29308 = bb->flags;
  D.29312 = D.29308 | 1;
  bb->flags = D.29312;
  i = 0;
  goto <D.25374>;
  <D.25373>:
  D.29313 = bb->out_bb;
  i.126 = (unsigned int) i;
  D.29315 = i.126 * 4;
  D.29316 = D.29313 + D.29315;
  D.29317 = *D.29316;
  compute_reachable (D.29317);
  i = i + 1;
  <D.25374>:
  D.29318 = bb->out_count;
  D.29319 = (int) D.29318;
  if (D.29319 > i) goto <D.25373>; else goto <D.25375>;
  <D.25375>:
  <D.29311>:
}


print_dfn (struct MonoCompile * cfg)
{
  struct MonoMethod * D.29320;
  struct MonoBasicBlock * * D.29321;
  unsigned int i.127;
  unsigned int D.29323;
  struct MonoBasicBlock * * D.29324;
  int D.29325;
  int D.29326;
  struct MonoBasicBlock * * D.29327;
  unsigned int j.128;
  unsigned int D.29329;
  struct MonoBasicBlock * * D.29330;
  struct MonoBasicBlock * D.29331;
  int D.29332;
  short int D.29333;
  int D.29334;
  struct MonoBasicBlock * * D.29335;
  struct MonoBasicBlock * * D.29336;
  struct MonoBasicBlock * D.29337;
  int D.29338;
  short int D.29339;
  int D.29340;
  int iftmp.129;
  struct MonoBasicBlock * D.29342;
  struct MonoBitSet * D.29348;
  int D.29349;
  unsigned int D.29350;
  unsigned int D.29351;
  unsigned int D.29352;
  int D.29353;
  unsigned int D.29354;
  unsigned int D.29355;
  _Bool D.29356;
  long int D.29357;
  long int D.29358;
  guint iftmp.130;
  struct MonoBitSet * D.29367;
  unsigned int i.131;
  unsigned int D.29371;
  int i;
  int j;
  char * code;
  struct MonoBasicBlock * bb;
  struct MonoInst * c;

  {
    char * method_name;

    D.29320 = cfg->method;
    method_name = mono_method_full_name (D.29320, 1);
    monoeg_g_print ("IR code for method %s\n", method_name);
    monoeg_g_free (method_name);
  }
  i = 0;
  goto <D.24843>;
  <D.24842>:
  D.29321 = cfg->bblocks;
  i.127 = (unsigned int) i;
  D.29323 = i.127 * 4;
  D.29324 = D.29321 + D.29323;
  bb = *D.29324;
  code = monoeg_strdup ("\n");
  D.29325 = bb->block_num;
  D.29326 = bb->cil_length;
  monoeg_g_print ("\nBB%d (%d) (len: %d): %s", D.29325, i, D.29326, code);
  c = bb->code;
  goto <D.24834>;
  <D.24833>:
  mono_print_ins_index (-1, c);
  c = c->next;
  <D.24834>:
  if (c != 0B) goto <D.24833>; else goto <D.24835>;
  <D.24835>:
  monoeg_g_print ("\tprev:");
  j = 0;
  goto <D.24837>;
  <D.24836>:
  D.29327 = bb->in_bb;
  j.128 = (unsigned int) j;
  D.29329 = j.128 * 4;
  D.29330 = D.29327 + D.29329;
  D.29331 = *D.29330;
  D.29332 = D.29331->block_num;
  monoeg_g_print (" BB%d", D.29332);
  j = j + 1;
  <D.24837>:
  D.29333 = bb->in_count;
  D.29334 = (int) D.29333;
  if (D.29334 > j) goto <D.24836>; else goto <D.24838>;
  <D.24838>:
  monoeg_g_print ("\t\tsucc:");
  j = 0;
  goto <D.24840>;
  <D.24839>:
  D.29335 = bb->out_bb;
  j.128 = (unsigned int) j;
  D.29329 = j.128 * 4;
  D.29336 = D.29335 + D.29329;
  D.29337 = *D.29336;
  D.29338 = D.29337->block_num;
  monoeg_g_print (" BB%d", D.29338);
  j = j + 1;
  <D.24840>:
  D.29339 = bb->out_count;
  D.29340 = (int) D.29339;
  if (D.29340 > j) goto <D.24839>; else goto <D.24841>;
  <D.24841>:
  D.29342 = bb->idom;
  if (D.29342 != 0B) goto <D.29343>; else goto <D.29344>;
  <D.29343>:
  D.29342 = bb->idom;
  iftmp.129 = D.29342->block_num;
  goto <D.29345>;
  <D.29344>:
  iftmp.129 = -1;
  <D.29345>:
  monoeg_g_print ("\n\tidom: BB%d\n", iftmp.129);
  D.29342 = bb->idom;
  if (D.29342 != 0B) goto <D.29346>; else goto <D.29347>;
  <D.29346>:
  D.29348 = bb->dominators;
  D.29342 = bb->idom;
  D.29349 = D.29342->dfn;
  D.29350 = (unsigned int) D.29349;
  D.29351 = D.29350 / 32;
  D.29352 = D.29348->data[D.29351];
  D.29342 = bb->idom;
  D.29349 = D.29342->dfn;
  D.29353 = D.29349 & 31;
  D.29354 = 1 << D.29353;
  D.29355 = D.29352 & D.29354;
  D.29356 = D.29355 == 0;
  D.29357 = (long int) D.29356;
  D.29358 = __builtin_expect (D.29357, 0);
  if (D.29358 != 0) goto <D.29359>; else goto <D.29360>;
  <D.29359>:
  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.29360>:
  <D.29347>:
  D.29348 = bb->dominators;
  if (D.29348 != 0B) goto <D.29361>; else goto <D.29362>;
  <D.29361>:
  D.29348 = bb->dominators;
  D.29342 = bb->idom;
  if (D.29342 != 0B) goto <D.29364>; else goto <D.29365>;
  <D.29364>:
  D.29342 = bb->idom;
  D.29349 = D.29342->dfn;
  iftmp.130 = (guint) D.29349;
  goto <D.29366>;
  <D.29365>:
  iftmp.130 = 4294967295;
  <D.29366>:
  mono_blockset_print (cfg, D.29348, "\tdominators", iftmp.130);
  <D.29362>:
  D.29367 = bb->dfrontier;
  if (D.29367 != 0B) goto <D.29368>; else goto <D.29369>;
  <D.29368>:
  D.29367 = bb->dfrontier;
  mono_blockset_print (cfg, D.29367, "\tdfrontier", 4294967295);
  <D.29369>:
  monoeg_g_free (code);
  i = i + 1;
  <D.24843>:
  i.131 = (unsigned int) i;
  D.29371 = cfg->num_bblocks;
  if (i.131 < D.29371) goto <D.24842>; else goto <D.24844>;
  <D.24844>:
  monoeg_g_print ("\n");
}


df_visit (struct MonoBasicBlock * start, int * dfn, struct MonoBasicBlock * * array)
{
  int D.29372;
  unsigned int D.29373;
  unsigned int D.29374;
  struct MonoBasicBlock * * D.29375;
  struct MonoBasicBlock * * D.29376;
  unsigned int i.132;
  unsigned int D.29378;
  struct MonoBasicBlock * * D.29379;
  struct MonoBasicBlock * D.29380;
  int D.29381;
  int D.29384;
  short int D.29385;
  int D.29386;
  int i;

  D.29372 = *dfn;
  D.29373 = (unsigned int) D.29372;
  D.29374 = D.29373 * 4;
  D.29375 = array + D.29374;
  *D.29375 = start;
  i = 0;
  goto <D.24337>;
  <D.24336>:
  D.29376 = start->out_bb;
  i.132 = (unsigned int) i;
  D.29378 = i.132 * 4;
  D.29379 = D.29376 + D.29378;
  D.29380 = *D.29379;
  D.29381 = D.29380->dfn;
  if (D.29381 != 0) goto <D.29382>; else goto <D.29383>;
  <D.29382>:
  // predicted unlikely by continue predictor.
  goto <D.24335>;
  <D.29383>:
  D.29372 = *dfn;
  D.29384 = D.29372 + 1;
  *dfn = D.29384;
  D.29376 = start->out_bb;
  i.132 = (unsigned int) i;
  D.29378 = i.132 * 4;
  D.29379 = D.29376 + D.29378;
  D.29380 = *D.29379;
  D.29372 = *dfn;
  D.29380->dfn = D.29372;
  D.29376 = start->out_bb;
  i.132 = (unsigned int) i;
  D.29378 = i.132 * 4;
  D.29379 = D.29376 + D.29378;
  D.29380 = *D.29379;
  D.29380->df_parent = start;
  D.29372 = *dfn;
  D.29373 = (unsigned int) D.29372;
  D.29374 = D.29373 * 4;
  D.29375 = array + D.29374;
  D.29376 = start->out_bb;
  i.132 = (unsigned int) i;
  D.29378 = i.132 * 4;
  D.29379 = D.29376 + D.29378;
  D.29380 = *D.29379;
  *D.29375 = D.29380;
  D.29376 = start->out_bb;
  i.132 = (unsigned int) i;
  D.29378 = i.132 * 4;
  D.29379 = D.29376 + D.29378;
  D.29380 = *D.29379;
  df_visit (D.29380, dfn, array);
  <D.24335>:
  i = i + 1;
  <D.24337>:
  D.29385 = start->out_count;
  D.29386 = (int) D.29385;
  if (D.29386 > i) goto <D.24336>; else goto <D.24338>;
  <D.24338>:
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.29387;
  unsigned int D.29388;

  D.29388 = __sync_add_and_fetch_4 (val, 1);
  D.29387 = (gint32) D.29388;
  return D.29387;
}


create_jit_info (struct MonoCompile * cfg, struct MonoMethod * method_to_compile)
{
  struct MonoMethod * D.29390;
  _Bool D.29391;
  long int D.29392;
  long int D.29393;
  struct MonoGenericSharingContext * D.29396;
  unsigned int D.29400;
  unsigned int D.29401;
  struct MonoMethod * D.29404;
  short unsigned int D.29405;
  int D.29406;
  int D.29407;
  unsigned int D.29408;
  unsigned int D.29409;
  int D.29410;
  struct GSList * D.29413;
  struct MonoBasicBlock * D.29416;
  int D.29417;
  int D.29418;
  struct MonoBasicBlock * * D.29419;
  unsigned int D.29420;
  unsigned int D.29421;
  unsigned int D.29422;
  unsigned int D.29423;
  struct MonoBasicBlock * * D.29424;
  _Bool D.29425;
  long int D.29426;
  long int D.29427;
  int D.29430;
  unsigned int num_holes.133;
  unsigned int D.29436;
  unsigned int D.29437;
  unsigned int D.29438;
  _Bool D.29439;
  long int D.29440;
  long int D.29441;
  unsigned char D.29444;
  unsigned int D.29449;
  <unnamed-unsigned:15> D.29451;
  unsigned int D.29452;
  unsigned int D.29453;
  unsigned int num_clauses.134;
  unsigned int D.29457;
  unsigned int generic_info_size.135;
  unsigned int D.29459;
  unsigned int holes_size.136;
  unsigned int D.29461;
  unsigned int arch_eh_info_size.137;
  unsigned int D.29463;
  unsigned int cas_size.138;
  unsigned int D.29465;
  unsigned int D.29466;
  struct MonoDomain * D.29468;
  unsigned char * D.29469;
  unsigned int D.29470;
  int D.29471;
  unsigned int D.29472;
  unsigned int D.29473;
  unsigned int D.29474;
  _Bool D.29475;
  <unnamed-signed:1> D.29476;
  short unsigned int D.29477;
  <unnamed-unsigned:15> D.29478;
  _Bool D.29483;
  long int D.29484;
  long int D.29485;
  void * D.29490;
  void * D.29492;
  struct MonoGenericSharingContext * D.29493;
  short unsigned int D.29496;
  int D.29497;
  int D.29498;
  struct MonoGenericContext * D.29500;
  struct MonoGenericInst * D.29501;
  struct MonoClass * D.29503;
  unsigned int D.29504;
  unsigned int D.29505;
  struct MonoInst * D.29506;
  _Bool D.29507;
  long int D.29508;
  long int D.29509;
  struct MonoGenericContext * D.29516;
  struct MonoGenericInst * D.29517;
  short unsigned int D.29521;
  _Bool D.29522;
  long int D.29523;
  long int D.29524;
  struct MonoInst * * D.29527;
  unsigned int D.29530;
  int D.29531;
  int D.29534;
  unsigned int D.29535;
  unsigned int D.29536;
  void * D.29537;
  void * D.29539;
  struct MonoDwarfLocListEntry * D.29540;
  unsigned int i.139;
  unsigned int D.29542;
  struct MonoDwarfLocListEntry * D.29543;
  void * D.29544;
  int D.29547;
  _Bool D.29548;
  long int D.29549;
  long int D.29550;
  unsigned char D.29553;
  int D.29554;
  int D.29558;
  unsigned char D.29559;
  int D.29565;
  unsigned char D.29566;
  int D.29567;
  short unsigned int D.29570;
  struct MonoBasicBlock * D.29571;
  int D.29572;
  int D.29573;
  unsigned int D.29574;
  unsigned int D.29575;
  unsigned int D.29576;
  unsigned int D.29577;
  struct MonoBasicBlock * * D.29578;
  _Bool D.29579;
  long int D.29580;
  long int D.29581;
  int D.29584;
  int D.29587;
  int D.29588;
  int i.140;
  struct MonoExceptionClause * D.29590;
  int D.29591;
  struct MonoExceptionClause * D.29592;
  int D.29593;
  int D.29594;
  int D.29595;
  short unsigned int D.29596;
  unsigned int D.29597;
  short unsigned int D.29598;
  short unsigned int D.29599;
  short unsigned int D.29600;
  short unsigned int D.29603;
  int D.29604;
  unsigned int D.29605;
  short unsigned int D.29606;
  int D.29607;
  _Bool D.29608;
  long int D.29609;
  long int D.29610;
  struct MonoJitExceptionInfo * D.29621;
  struct MonoJitExceptionInfo * D.29622;
  unsigned int D.29624;
  unsigned int D.29625;
  unsigned int i.141;
  unsigned int D.29629;
  unsigned int D.29630;
  unsigned int D.29631;
  int D.29632;
  int iftmp.142;
  unsigned int D.29637;
  unsigned int D.29640;
  unsigned int D.29641;
  struct MonoBasicBlock * * D.29642;
  _Bool D.29643;
  long int D.29644;
  long int D.29645;
  int D.29648;
  sizetype D.29649;
  void * D.29650;
  struct MonoClass * D.29652;
  unsigned int D.29653;
  unsigned int D.29654;
  struct MonoBasicBlock * * D.29655;
  _Bool D.29658;
  long int D.29659;
  long int D.29660;
  unsigned int D.29663;
  unsigned int D.29664;
  void * D.29667;
  void * D.29668;
  unsigned int D.29669;
  unsigned int D.29670;
  unsigned int D.29671;
  struct MonoBasicBlock * * D.29672;
  unsigned int j.143;
  unsigned int D.29678;
  struct MonoBasicBlock * * D.29679;
  int D.29682;
  unsigned int D.29687;
  struct MonoBasicBlock * * D.29688;
  struct MonoBasicBlock * D.29691;
  int D.29692;
  int D.29693;
  int D.29694;
  sizetype D.29695;
  struct MonoExceptionClause * D.29696;
  void * D.29699;
  int D.29704;
  int D.29705;
  int D.29706;
  int D.29707;
  sizetype D.29708;
  void * D.29709;
  unsigned int D.29712;
  unsigned int D.29713;
  unsigned int D.29714;
  unsigned int D.29717;
  struct MonoBasicBlock * * D.29718;
  unsigned int j.144;
  unsigned int D.29723;
  struct MonoBasicBlock * * D.29724;
  int D.29727;
  int D.29730;
  unsigned int D.29732;
  sizetype end_offset.145;
  void * D.29734;
  int D.29735;
  void * D.29738;
  int D.29739;
  void * D.29740;
  int D.29741;
  void * D.29742;
  int D.29743;
  void * D.29744;
  int D.29745;
  unsigned int D.29746;
  <unnamed-unsigned:15> D.29747;
  int D.29748;
  guint8 * D.29749;
  unsigned int D.29752;
  unsigned int D.29753;
  struct GSList * D.29755;
  unsigned int info_len.146;
  unsigned int D.29759;
  struct MonoJitInfo * D.29760;
  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.29390 = cfg->method;
  D.29391 = D.29390 != method_to_compile;
  D.29392 = (long int) D.29391;
  D.29393 = __builtin_expect (D.29392, 0);
  if (D.29393 != 0) goto <D.29394>; else goto <D.29395>;
  <D.29394>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4280, "method_to_compile == cfg->method");
  <D.29395>:
  header = cfg->header;
  D.29396 = cfg->generic_sharing_context;
  if (D.29396 != 0B) goto <D.29397>; else goto <D.29398>;
  <D.29397>:
  generic_info_size = 20;
  goto <D.29399>;
  <D.29398>:
  generic_info_size = 0;
  <D.29399>:
  D.29400 = BIT_FIELD_REF <*cfg, 32, 3424>;
  D.29401 = D.29400 & 512;
  if (D.29401 != 0) goto <D.29402>; else goto <D.29403>;
  <D.29402>:
  {
    struct MonoJitArgumentInfo * arg_info;
    struct MonoMethodSignature * sig;

    D.29404 = cfg->method_to_register;
    sig = mono_method_signature (D.29404);
    D.29405 = sig->param_count;
    D.29406 = (int) D.29405;
    D.29407 = D.29406 + 1;
    D.29408 = (unsigned int) D.29407;
    D.29409 = D.29408 * 6;
    arg_info = __builtin_alloca (D.29409);
    D.29396 = cfg->generic_sharing_context;
    D.29405 = sig->param_count;
    D.29406 = (int) D.29405;
    D.29410 = mono_arch_get_argument_info (D.29396, sig, D.29406, arg_info);
    stack_size = (guint32) D.29410;
    if (stack_size != 0) goto <D.29411>; else goto <D.29412>;
    <D.29411>:
    arch_eh_info_size = 4;
    <D.29412>:
  }
  <D.29403>:
  D.29413 = cfg->try_block_holes;
  if (D.29413 != 0B) goto <D.29414>; else goto <D.29415>;
  <D.29414>:
  tmp = cfg->try_block_holes;
  goto <D.25413>;
  <D.25412>:
  {
    struct TryBlockHole * hole;
    struct MonoExceptionClause * ec;
    int hole_end;
    struct MonoBasicBlock * clause_last_bb;

    hole = tmp->data;
    ec = hole->clause;
    D.29416 = hole->basic_block;
    D.29417 = D.29416->native_offset;
    D.29416 = hole->basic_block;
    D.29418 = D.29416->native_length;
    hole_end = D.29417 + D.29418;
    D.29419 = cfg->cil_offset_to_bb;
    D.29420 = ec->try_offset;
    D.29421 = ec->try_len;
    D.29422 = D.29420 + D.29421;
    D.29423 = D.29422 * 4;
    D.29424 = D.29419 + D.29423;
    clause_last_bb = *D.29424;
    D.29425 = clause_last_bb == 0B;
    D.29426 = (long int) D.29425;
    D.29427 = __builtin_expect (D.29426, 0);
    if (D.29427 != 0) goto <D.29428>; else goto <D.29429>;
    <D.29428>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4309, "clause_last_bb");
    <D.29429>:
    D.29430 = clause_last_bb->native_offset;
    if (D.29430 != hole_end) goto <D.29431>; else goto <D.29432>;
    <D.29431>:
    num_holes = num_holes + 1;
    <D.29432>:
  }
  tmp = tmp->next;
  <D.25413>:
  if (tmp != 0B) goto <D.25412>; else goto <D.25414>;
  <D.25414>:
  if (num_holes != 0) goto <D.29433>; else goto <D.29434>;
  <D.29433>:
  num_holes.133 = (unsigned int) num_holes;
  D.29436 = num_holes.133 * 8;
  D.29437 = D.29436 + 4;
  holes_size = (int) D.29437;
  <D.29434>:
  D.29438 = cfg->verbose_level;
  D.29439 = D.29438 > 3;
  D.29440 = (long int) D.29439;
  D.29441 = __builtin_expect (D.29440, 0);
  if (D.29441 != 0) goto <D.29442>; else goto <D.29443>;
  <D.29442>:
  printf ("Number of try block holes %d\n", num_holes);
  <D.29443>:
  <D.29415>:
  D.29404 = cfg->method_to_register;
  D.29444 = mono_method_has_declsec (D.29404);
  if (D.29444 != 0) goto <D.29445>; else goto <D.29446>;
  <D.29445>:
  cas_size = 4;
  <D.29446>:
  if (0 != 0) goto <D.29447>; else goto <D.29448>;
  <D.29447>:
  D.29449 = cfg->llvm_ex_info_len;
  num_clauses = (int) D.29449;
  goto <D.29450>;
  <D.29448>:
  D.29451 = header->num_clauses;
  num_clauses = (int) D.29451;
  <D.29450>:
  D.29390 = cfg->method;
  D.29452 = BIT_FIELD_REF <*D.29390, 32, 160>;
  D.29453 = D.29452 & 512;
  if (D.29453 != 0) goto <D.29454>; else goto <D.29455>;
  <D.29454>:
  num_clauses.134 = (unsigned int) num_clauses;
  D.29457 = num_clauses.134 * 24;
  generic_info_size.135 = (unsigned int) generic_info_size;
  D.29459 = D.29457 + generic_info_size.135;
  holes_size.136 = (unsigned int) holes_size;
  D.29461 = D.29459 + holes_size.136;
  arch_eh_info_size.137 = (unsigned int) arch_eh_info_size;
  D.29463 = D.29461 + arch_eh_info_size.137;
  cas_size.138 = (unsigned int) cas_size;
  D.29465 = D.29463 + cas_size.138;
  D.29466 = D.29465 + 28;
  jinfo = monoeg_malloc0 (D.29466);
  goto <D.29467>;
  <D.29455>:
  D.29468 = cfg->domain;
  num_clauses.134 = (unsigned int) num_clauses;
  D.29457 = num_clauses.134 * 24;
  generic_info_size.135 = (unsigned int) generic_info_size;
  D.29459 = D.29457 + generic_info_size.135;
  holes_size.136 = (unsigned int) holes_size;
  D.29461 = D.29459 + holes_size.136;
  arch_eh_info_size.137 = (unsigned int) arch_eh_info_size;
  D.29463 = D.29461 + arch_eh_info_size.137;
  cas_size.138 = (unsigned int) cas_size;
  D.29465 = D.29463 + cas_size.138;
  D.29466 = D.29465 + 28;
  jinfo = mono_domain_alloc0 (D.29468, D.29466);
  <D.29467>:
  D.29404 = cfg->method_to_register;
  jinfo->d.method = D.29404;
  D.29469 = cfg->native_code;
  jinfo->code_start = D.29469;
  D.29470 = cfg->code_len;
  D.29471 = (int) D.29470;
  jinfo->code_size = D.29471;
  D.29472 = cfg->used_int_regs;
  jinfo->used_regs = D.29472;
  D.29473 = cfg->opt;
  D.29474 = D.29473 & 512;
  D.29475 = D.29474 != 0;
  D.29476 = (<unnamed-signed:1>) D.29475;
  jinfo->domain_neutral = D.29476;
  D.29477 = (short unsigned int) num_clauses;
  D.29478 = (<unnamed-unsigned:15>) D.29477;
  jinfo->num_clauses = D.29478;
  if (0 != 0) goto <D.29479>; else goto <D.29480>;
  <D.29479>:
  jinfo->from_llvm = -1;
  <D.29480>:
  D.29396 = cfg->generic_sharing_context;
  if (D.29396 != 0B) goto <D.29481>; else goto <D.29482>;
  <D.29481>:
  {
    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.29483 = gi == 0B;
    D.29484 = (long int) D.29483;
    D.29485 = __builtin_expect (D.29484, 0);
    if (D.29485 != 0) goto <D.29486>; else goto <D.29487>;
    <D.29486>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4357, "gi");
    <D.29487>:
    D.29390 = cfg->method;
    D.29452 = BIT_FIELD_REF <*D.29390, 32, 160>;
    D.29453 = D.29452 & 512;
    if (D.29453 != 0) goto <D.29488>; else goto <D.29489>;
    <D.29488>:
    D.29490 = monoeg_malloc0 (8);
    gi->generic_sharing_context = D.29490;
    goto <D.29491>;
    <D.29489>:
    D.29468 = cfg->domain;
    D.29492 = mono_domain_alloc0 (D.29468, 8);
    gi->generic_sharing_context = D.29492;
    <D.29491>:
    D.29493 = gi->generic_sharing_context;
    D.29396 = cfg->generic_sharing_context;
    memcpy (D.29493, D.29396, 8);
    D.29496 = method_to_compile->flags;
    D.29497 = (int) D.29496;
    D.29498 = D.29497 & 16;
    if (D.29498 != 0) goto <D.29494>; else goto <D.29499>;
    <D.29499>:
    D.29500 = mini_method_get_context (method_to_compile);
    D.29501 = D.29500->method_inst;
    if (D.29501 != 0B) goto <D.29494>; else goto <D.29502>;
    <D.29502>:
    D.29503 = method_to_compile->klass;
    D.29504 = BIT_FIELD_REF <*D.29503, 32, 160>;
    D.29505 = D.29504 & 8;
    if (D.29505 != 0) goto <D.29494>; else goto <D.29495>;
    <D.29494>:
    D.29506 = cfg->rgctx_var;
    D.29507 = D.29506 == 0B;
    D.29508 = (long int) D.29507;
    D.29509 = __builtin_expect (D.29508, 0);
    if (D.29509 != 0) goto <D.29510>; else goto <D.29511>;
    <D.29510>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4368, "cfg->rgctx_var");
    <D.29511>:
    <D.29495>:
    gi->has_this = -1;
    D.29496 = method_to_compile->flags;
    D.29497 = (int) D.29496;
    D.29498 = D.29497 & 16;
    if (D.29498 != 0) goto <D.29512>; else goto <D.29515>;
    <D.29515>:
    D.29516 = mini_method_get_context (method_to_compile);
    D.29517 = D.29516->method_inst;
    if (D.29517 != 0B) goto <D.29512>; else goto <D.29518>;
    <D.29518>:
    D.29503 = method_to_compile->klass;
    D.29504 = BIT_FIELD_REF <*D.29503, 32, 160>;
    D.29505 = D.29504 & 8;
    if (D.29505 != 0) goto <D.29512>; else goto <D.29513>;
    <D.29512>:
    inst = cfg->rgctx_var;
    if (1 != 0) goto <D.29519>; else goto <D.29520>;
    <D.29519>:
    D.29521 = inst->opcode;
    D.29522 = D.29521 != 367;
    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", 4378, "inst->opcode == OP_REGOFFSET");
    <D.29526>:
    <D.29520>:
    loclist = cfg->rgctx_loclist;
    goto <D.29514>;
    <D.29513>:
    D.29527 = cfg->args;
    inst = *D.29527;
    loclist = cfg->this_loclist;
    <D.29514>:
    if (loclist != 0B) goto <D.29528>; else goto <D.29529>;
    <D.29528>:
    {
      struct GSList * l;
      int i;

      D.29530 = monoeg_g_slist_length (loclist);
      D.29531 = (int) D.29530;
      gi->nlocs = D.29531;
      D.29390 = cfg->method;
      D.29452 = BIT_FIELD_REF <*D.29390, 32, 160>;
      D.29453 = D.29452 & 512;
      if (D.29453 != 0) goto <D.29532>; else goto <D.29533>;
      <D.29532>:
      D.29534 = gi->nlocs;
      D.29535 = (unsigned int) D.29534;
      D.29536 = D.29535 * 20;
      D.29537 = monoeg_malloc0 (D.29536);
      gi->locations = D.29537;
      goto <D.29538>;
      <D.29533>:
      D.29468 = cfg->domain;
      D.29534 = gi->nlocs;
      D.29535 = (unsigned int) D.29534;
      D.29536 = D.29535 * 20;
      D.29539 = mono_domain_alloc0 (D.29468, D.29536);
      gi->locations = D.29539;
      <D.29538>:
      i = 0;
      l = loclist;
      goto <D.25421>;
      <D.25420>:
      D.29540 = gi->locations;
      i.139 = (unsigned int) i;
      D.29542 = i.139 * 20;
      D.29543 = D.29540 + D.29542;
      D.29544 = l->data;
      memcpy (D.29543, D.29544, 20);
      i = i + 1;
      l = l->next;
      <D.25421>:
      if (l != 0B) goto <D.25420>; else goto <D.25422>;
      <D.25422>:
    }
    <D.29529>:
    if (0 != 0) goto <D.29545>; else goto <D.29546>;
    <D.29545>:
    D.29547 = cfg->llvm_this_reg;
    D.29548 = D.29547 == -1;
    D.29549 = (long int) D.29548;
    D.29550 = __builtin_expect (D.29549, 0);
    if (D.29550 != 0) goto <D.29551>; else goto <D.29552>;
    <D.29551>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4403, "cfg->llvm_this_reg != -1");
    <D.29552>:
    gi->this_in_reg = 0;
    D.29547 = cfg->llvm_this_reg;
    D.29553 = (unsigned char) D.29547;
    gi->this_reg = D.29553;
    D.29554 = cfg->llvm_this_offset;
    gi->this_offset = D.29554;
    goto <D.29555>;
    <D.29546>:
    D.29521 = inst->opcode;
    if (D.29521 == 366) goto <D.29556>; else goto <D.29557>;
    <D.29556>:
    gi->this_in_reg = -1;
    D.29558 = inst->dreg;
    D.29559 = (unsigned char) D.29558;
    gi->this_reg = D.29559;
    goto <D.29560>;
    <D.29557>:
    D.29521 = inst->opcode;
    D.29522 = D.29521 != 367;
    D.29523 = (long int) D.29522;
    D.29524 = __builtin_expect (D.29523, 0);
    if (D.29524 != 0) goto <D.29561>; else goto <D.29562>;
    <D.29561>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4411, "inst->opcode == OP_REGOFFSET");
    <D.29562>:
    if (0 != 0) goto <D.29563>; else goto <D.29564>;
    <D.29563>:
    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.29564>:
    gi->this_in_reg = 0;
    D.29565 = inst->sreg1;
    D.29566 = (unsigned char) D.29565;
    gi->this_reg = D.29566;
    D.29567 = inst->data.op[0].const_val;
    gi->this_offset = D.29567;
    <D.29560>:
    <D.29555>:
  }
  <D.29482>:
  if (num_holes != 0) goto <D.29568>; else goto <D.29569>;
  <D.29568>:
  {
    struct MonoTryBlockHoleTableJitInfo * table;
    int i;

    jinfo->has_try_block_holes = -1;
    table = mono_jit_info_get_try_block_hole_table_info (jinfo);
    D.29570 = (short unsigned int) num_holes;
    table->num_holes = D.29570;
    i = 0;
    tmp = cfg->try_block_holes;
    goto <D.25433>;
    <D.25432>:
    {
      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.29571 = hole_data->basic_block;
      D.29572 = D.29571->native_offset;
      D.29571 = hole_data->basic_block;
      D.29573 = D.29571->native_length;
      hole_end = D.29572 + D.29573;
      D.29419 = cfg->cil_offset_to_bb;
      D.29574 = ec->try_offset;
      D.29575 = ec->try_len;
      D.29576 = D.29574 + D.29575;
      D.29577 = D.29576 * 4;
      D.29578 = D.29419 + D.29577;
      clause_last_bb = *D.29578;
      D.29579 = clause_last_bb == 0B;
      D.29580 = (long int) D.29579;
      D.29581 = __builtin_expect (D.29580, 0);
      if (D.29581 != 0) goto <D.29582>; else goto <D.29583>;
      <D.29582>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4440, "clause_last_bb");
      <D.29583>:
      D.29584 = clause_last_bb->native_offset;
      if (D.29584 == hole_end) goto <D.29585>; else goto <D.29586>;
      <D.29585>:
      // predicted unlikely by continue predictor.
      goto <D.25431>;
      <D.29586>:
      D.29587 = hole_data->start_offset;
      D.29571 = hole_data->basic_block;
      D.29572 = D.29571->native_offset;
      D.29588 = D.29587 - D.29572;
      start_bb_offset = (guint32) D.29588;
      i.140 = i;
      i = i.140 + 1;
      hole = &table->holes[i.140];
      D.29590 = hole_data->clause;
      D.29591 = (int) D.29590;
      D.29592 = header->clauses;
      D.29593 = (int) D.29592;
      D.29594 = D.29591 - D.29593;
      D.29595 = D.29594 /[ex] 24;
      D.29596 = (short unsigned int) D.29595;
      hole->clause = D.29596;
      D.29587 = hole_data->start_offset;
      D.29597 = (unsigned int) D.29587;
      hole->offset = D.29597;
      D.29571 = hole_data->basic_block;
      D.29573 = D.29571->native_length;
      D.29598 = (short unsigned int) D.29573;
      D.29599 = (short unsigned int) start_bb_offset;
      D.29600 = D.29598 - D.29599;
      hole->length = D.29600;
      D.29438 = cfg->verbose_level;
      D.29439 = D.29438 > 3;
      D.29440 = (long int) D.29439;
      D.29441 = __builtin_expect (D.29440, 0);
      if (D.29441 != 0) goto <D.29601>; else goto <D.29602>;
      <D.29601>:
      D.29603 = hole->clause;
      D.29604 = (int) D.29603;
      D.29605 = hole->offset;
      D.29606 = hole->length;
      D.29607 = (int) D.29606;
      printf ("\tTry block hole at eh clause %d offset %x length %x\n", D.29604, D.29605, D.29607);
      <D.29602>:
    }
    <D.25431>:
    tmp = tmp->next;
    <D.25433>:
    if (tmp != 0B) goto <D.25432>; else goto <D.25434>;
    <D.25434>:
    D.29608 = i != num_holes;
    D.29609 = (long int) D.29608;
    D.29610 = __builtin_expect (D.29609, 0);
    if (D.29610 != 0) goto <D.29611>; else goto <D.29612>;
    <D.29611>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4455, "i == num_holes");
    <D.29612>:
  }
  <D.29569>:
  if (arch_eh_info_size != 0) goto <D.29613>; else goto <D.29614>;
  <D.29613>:
  {
    struct MonoArchEHJitInfo * info;

    jinfo->has_arch_eh_info = -1;
    info = mono_jit_info_get_arch_eh_info (jinfo);
    info->stack_size = stack_size;
  }
  <D.29614>:
  if (cas_size != 0) goto <D.29615>; else goto <D.29616>;
  <D.29615>:
  jinfo->has_cas_info = -1;
  <D.29616>:
  if (0 != 0) goto <D.29617>; else goto <D.29618>;
  <D.29617>:
  if (num_clauses != 0) goto <D.29619>; else goto <D.29620>;
  <D.29619>:
  D.29621 = &jinfo->clauses[0];
  D.29622 = cfg->llvm_ex_info;
  num_clauses.134 = (unsigned int) num_clauses;
  D.29457 = num_clauses.134 * 24;
  memcpy (D.29621, D.29622, D.29457);
  <D.29620>:
  goto <D.29623>;
  <D.29618>:
  D.29624 = BIT_FIELD_REF <*header, 32, 64>;
  D.29625 = D.29624 & 2147418112;
  if (D.29625 != 0) goto <D.29626>; else goto <D.29627>;
  <D.29626>:
  {
    int i;

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

      D.29592 = header->clauses;
      i.141 = (unsigned int) i;
      D.29629 = i.141 * 24;
      ec = D.29592 + D.29629;
      ei = &jinfo->clauses[i];
      D.29630 = ec->flags;
      ei->flags = D.29630;
      D.29631 = ec->handler_offset;
      D.29632 = (int) D.29631;
      exvar = mono_find_exvar_for_offset (cfg, D.29632);
      if (exvar != 0B) goto <D.29634>; else goto <D.29635>;
      <D.29634>:
      iftmp.142 = exvar->data.op[0].const_val;
      goto <D.29636>;
      <D.29635>:
      iftmp.142 = 0;
      <D.29636>:
      ei->exvar_offset = iftmp.142;
      D.29637 = ei->flags;
      if (D.29637 == 1) goto <D.29638>; else goto <D.29639>;
      <D.29638>:
      D.29419 = cfg->cil_offset_to_bb;
      D.29640 = ec->data.filter_offset;
      D.29641 = D.29640 * 4;
      D.29642 = D.29419 + D.29641;
      tblock = *D.29642;
      D.29643 = tblock == 0B;
      D.29644 = (long int) D.29643;
      D.29645 = __builtin_expect (D.29644, 0);
      if (D.29645 != 0) goto <D.29646>; else goto <D.29647>;
      <D.29646>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4490, "tblock");
      <D.29647>:
      D.29469 = cfg->native_code;
      D.29648 = tblock->native_offset;
      D.29649 = (sizetype) D.29648;
      D.29650 = D.29469 + D.29649;
      ei->data.filter = D.29650;
      goto <D.29651>;
      <D.29639>:
      D.29652 = ec->data.catch_class;
      ei->data.catch_class = D.29652;
      <D.29651>:
      D.29419 = cfg->cil_offset_to_bb;
      D.29653 = ec->try_offset;
      D.29654 = D.29653 * 4;
      D.29655 = D.29419 + D.29654;
      tblock = *D.29655;
      D.29643 = tblock == 0B;
      D.29644 = (long int) D.29643;
      D.29645 = __builtin_expect (D.29644, 0);
      if (D.29645 != 0) goto <D.29656>; else goto <D.29657>;
      <D.29656>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4497, "tblock");
      <D.29657>:
      D.29648 = tblock->native_offset;
      D.29658 = D.29648 == 0;
      D.29659 = (long int) D.29658;
      D.29660 = __builtin_expect (D.29659, 0);
      if (D.29660 != 0) goto <D.29661>; else goto <D.29662>;
      <D.29661>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4498, "tblock->native_offset");
      <D.29662>:
      D.29469 = cfg->native_code;
      D.29648 = tblock->native_offset;
      D.29649 = (sizetype) D.29648;
      D.29650 = D.29469 + D.29649;
      ei->try_start = D.29650;
      D.29663 = BIT_FIELD_REF <*tblock, 32, 896>;
      D.29664 = D.29663 & 8388608;
      if (D.29664 != 0) goto <D.29665>; else goto <D.29666>;
      <D.29665>:
      D.29667 = ei->try_start;
      D.29668 = D.29667 + 4294967295;
      ei->try_start = D.29668;
      <D.29666>:
      D.29419 = cfg->cil_offset_to_bb;
      D.29653 = ec->try_offset;
      D.29669 = ec->try_len;
      D.29670 = D.29653 + D.29669;
      D.29671 = D.29670 * 4;
      D.29672 = D.29419 + D.29671;
      tblock = *D.29672;
      D.29643 = tblock == 0B;
      D.29644 = (long int) D.29643;
      D.29645 = __builtin_expect (D.29644, 0);
      if (D.29645 != 0) goto <D.29673>; else goto <D.29674>;
      <D.29673>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4508, "tblock");
      <D.29674>:
      D.29648 = tblock->native_offset;
      if (D.29648 == 0) goto <D.29675>; else goto <D.29676>;
      <D.29675>:
      {
        int j;
        int end;

        D.29653 = ec->try_offset;
        D.29669 = ec->try_len;
        D.29670 = D.29653 + D.29669;
        j = (int) D.29670;
        D.29653 = ec->try_offset;
        end = (int) D.29653;
        goto <D.25446>;
        <D.25445>:
        {
          struct MonoBasicBlock * bb;

          D.29419 = cfg->cil_offset_to_bb;
          j.143 = (unsigned int) j;
          D.29678 = j.143 * 4;
          D.29679 = D.29419 + D.29678;
          bb = *D.29679;
          if (bb != 0B) goto <D.29680>; else goto <D.29681>;
          <D.29680>:
          D.29682 = bb->native_offset;
          if (D.29682 != 0) goto <D.29683>; else goto <D.29684>;
          <D.29683>:
          tblock = bb;
          goto <D.25444>;
          <D.29684>:
          <D.29681>:
        }
        j = j + -1;
        <D.25446>:
        if (j >= end) goto <D.25445>; else goto <D.25444>;
        <D.25444>:
      }
      <D.29676>:
      D.29469 = cfg->native_code;
      D.29648 = tblock->native_offset;
      D.29649 = (sizetype) D.29648;
      D.29650 = D.29469 + D.29649;
      ei->try_end = D.29650;
      D.29648 = tblock->native_offset;
      D.29658 = D.29648 == 0;
      D.29659 = (long int) D.29658;
      D.29660 = __builtin_expect (D.29659, 0);
      if (D.29660 != 0) goto <D.29685>; else goto <D.29686>;
      <D.29685>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4520, "tblock->native_offset");
      <D.29686>:
      D.29419 = cfg->cil_offset_to_bb;
      D.29631 = ec->handler_offset;
      D.29687 = D.29631 * 4;
      D.29688 = D.29419 + D.29687;
      tblock = *D.29688;
      D.29643 = tblock == 0B;
      D.29644 = (long int) D.29643;
      D.29645 = __builtin_expect (D.29644, 0);
      if (D.29645 != 0) goto <D.29689>; else goto <D.29690>;
      <D.29689>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4522, "tblock");
      <D.29690>:
      D.29469 = cfg->native_code;
      D.29648 = tblock->native_offset;
      D.29649 = (sizetype) D.29648;
      D.29650 = D.29469 + D.29649;
      ei->handler_start = D.29650;
      tmp = cfg->try_block_holes;
      goto <D.25451>;
      <D.25450>:
      {
        struct TryBlockHole * hole;
        void * hole_end;

        hole = tmp->data;
        D.29469 = cfg->native_code;
        D.29691 = hole->basic_block;
        D.29692 = D.29691->native_offset;
        D.29691 = hole->basic_block;
        D.29693 = D.29691->native_length;
        D.29694 = D.29692 + D.29693;
        D.29695 = (sizetype) D.29694;
        hole_end = D.29469 + D.29695;
        D.29696 = hole->clause;
        if (D.29696 == ec) goto <D.29697>; else goto <D.29698>;
        <D.29697>:
        D.29699 = ei->try_end;
        if (D.29699 == hole_end) goto <D.29700>; else goto <D.29701>;
        <D.29700>:
        D.29438 = cfg->verbose_level;
        D.29439 = D.29438 > 3;
        D.29440 = (long int) D.29439;
        D.29441 = __builtin_expect (D.29440, 0);
        if (D.29441 != 0) goto <D.29702>; else goto <D.29703>;
        <D.29702>:
        D.29699 = ei->try_end;
        D.29704 = (int) D.29699;
        D.29469 = cfg->native_code;
        D.29705 = (int) D.29469;
        D.29706 = D.29704 - D.29705;
        D.29707 = hole->start_offset;
        printf ("\tShortening try block %d from %x to %x\n", i, D.29706, D.29707);
        <D.29703>:
        D.29469 = cfg->native_code;
        D.29707 = hole->start_offset;
        D.29708 = (sizetype) D.29707;
        D.29709 = D.29469 + D.29708;
        ei->try_end = D.29709;
        goto <D.25449>;
        <D.29701>:
        <D.29698>:
      }
      tmp = tmp->next;
      <D.25451>:
      if (tmp != 0B) goto <D.25450>; else goto <D.25449>;
      <D.25449>:
      D.29630 = ec->flags;
      if (D.29630 == 2) goto <D.29710>; else goto <D.29711>;
      <D.29710>:
      {
        int end_offset;

        D.29631 = ec->handler_offset;
        D.29712 = ec->handler_len;
        D.29713 = D.29631 + D.29712;
        D.29714 = header->code_size;
        if (D.29713 < D.29714) goto <D.29715>; else goto <D.29716>;
        <D.29715>:
        D.29419 = cfg->cil_offset_to_bb;
        D.29631 = ec->handler_offset;
        D.29712 = ec->handler_len;
        D.29713 = D.29631 + D.29712;
        D.29717 = D.29713 * 4;
        D.29718 = D.29419 + D.29717;
        tblock = *D.29718;
        D.29648 = tblock->native_offset;
        if (D.29648 != 0) goto <D.29719>; else goto <D.29720>;
        <D.29719>:
        end_offset = tblock->native_offset;
        goto <D.29721>;
        <D.29720>:
        {
          int j;
          int end;

          D.29631 = ec->handler_offset;
          D.29712 = ec->handler_len;
          D.29713 = D.29631 + D.29712;
          j = (int) D.29713;
          D.29631 = ec->handler_offset;
          end = (int) D.29631;
          goto <D.25458>;
          <D.25457>:
          {
            struct MonoBasicBlock * bb;

            D.29419 = cfg->cil_offset_to_bb;
            j.144 = (unsigned int) j;
            D.29723 = j.144 * 4;
            D.29724 = D.29419 + D.29723;
            bb = *D.29724;
            if (bb != 0B) goto <D.29725>; else goto <D.29726>;
            <D.29725>:
            D.29727 = bb->native_offset;
            if (D.29727 != 0) goto <D.29728>; else goto <D.29729>;
            <D.29728>:
            tblock = bb;
            goto <D.25456>;
            <D.29729>:
            <D.29726>:
          }
          j = j + -1;
          <D.25458>:
          if (j >= end) goto <D.25457>; else goto <D.25456>;
          <D.25456>:
          D.29648 = tblock->native_offset;
          D.29730 = tblock->native_length;
          end_offset = D.29648 + D.29730;
        }
        <D.29721>:
        goto <D.29731>;
        <D.29716>:
        D.29732 = cfg->epilog_begin;
        end_offset = (int) D.29732;
        <D.29731>:
        D.29469 = cfg->native_code;
        end_offset.145 = (sizetype) end_offset;
        D.29734 = D.29469 + end_offset.145;
        ei->data.handler_end = D.29734;
      }
      <D.29711>:
    }
    i = i + 1;
    <D.25460>:
    D.29451 = header->num_clauses;
    D.29735 = (int) D.29451;
    if (D.29735 > i) goto <D.25459>; else goto <D.25461>;
    <D.25461>:
  }
  <D.29627>:
  <D.29623>:
  D.29438 = cfg->verbose_level;
  D.29439 = D.29438 > 3;
  D.29440 = (long int) D.29439;
  D.29441 = __builtin_expect (D.29440, 0);
  if (D.29441 != 0) goto <D.29736>; else goto <D.29737>;
  <D.29736>:
  {
    int i;

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

      ei = &jinfo->clauses[i];
      D.29738 = ei->try_start;
      D.29739 = (int) D.29738;
      D.29469 = cfg->native_code;
      D.29705 = (int) D.29469;
      start = D.29739 - D.29705;
      D.29740 = ei->try_end;
      D.29741 = (int) D.29740;
      D.29469 = cfg->native_code;
      D.29705 = (int) D.29469;
      end = D.29741 - D.29705;
      D.29742 = ei->handler_start;
      D.29743 = (int) D.29742;
      D.29469 = cfg->native_code;
      D.29705 = (int) D.29469;
      handler = D.29743 - D.29705;
      D.29744 = ei->data.handler_end;
      D.29745 = (int) D.29744;
      D.29469 = cfg->native_code;
      D.29705 = (int) D.29469;
      handler_end = D.29745 - D.29705;
      D.29746 = ei->flags;
      printf ("JitInfo EH clause %d flags %x try %x-%x handler %x-%x\n", i, D.29746, start, end, handler, handler_end);
    }
    i = i + 1;
    <D.25469>:
    D.29747 = jinfo->num_clauses;
    D.29748 = (int) D.29747;
    if (D.29748 > i) goto <D.25468>; else goto <D.25470>;
    <D.25470>:
  }
  <D.29737>:
  D.29749 = cfg->encoded_unwind_ops;
  if (D.29749 != 0B) goto <D.29750>; else goto <D.29751>;
  <D.29750>:
  D.29749 = cfg->encoded_unwind_ops;
  D.29752 = cfg->encoded_unwind_ops_len;
  D.29753 = mono_cache_unwind_info (D.29749, D.29752);
  jinfo->used_regs = D.29753;
  D.29749 = cfg->encoded_unwind_ops;
  monoeg_g_free (D.29749);
  goto <D.29754>;
  <D.29751>:
  D.29755 = cfg->unwind_ops;
  if (D.29755 != 0B) goto <D.29756>; else goto <D.29757>;
  <D.29756>:
  {
    guint32 info_len;
    guint8 * unwind_info;

    try
      {
        D.29755 = cfg->unwind_ops;
        unwind_info = mono_unwind_ops_encode (D.29755, &info_len);
        info_len.146 = info_len;
        D.29759 = mono_cache_unwind_info (unwind_info, info_len.146);
        jinfo->used_regs = D.29759;
        monoeg_g_free (unwind_info);
      }
    finally
      {
        info_len = {CLOBBER};
      }
  }
  <D.29757>:
  <D.29754>:
  D.29760 = jinfo;
  return D.29760;
}


mono_save_seq_point_info (struct MonoCompile * cfg)
{
  struct GPtrArray * D.29762;
  unsigned int D.29765;
  unsigned int D.29766;
  unsigned int D.29767;
  int D.29768;
  void * * D.29769;
  unsigned int i.147;
  unsigned int D.29771;
  void * * D.29772;
  int D.29773;
  int D.29774;
  unsigned char D.29775;
  int D.29776;
  int D.29777;
  int D.29780;
  int D.29781;
  unsigned int i.148;
  unsigned int D.29783;
  struct GSList * D.29784;
  int D.29787;
  int D.29789;
  int D.29794;
  unsigned int D.29795;
  unsigned int D.29796;
  struct GSList * * D.29797;
  struct GSList * D.29798;
  int D.29799;
  void * D.29800;
  struct GSList * D.29801;
  struct MonoInst * D.29803;
  short unsigned int D.29806;
  struct GSList * D.29813;
  int D.29816;
  int D.29823;
  unsigned int D.29824;
  unsigned int D.29825;
  struct GSList * * D.29826;
  struct GSList * D.29827;
  int D.29828;
  void * D.29829;
  struct GSList * D.29830;
  unsigned int D.29831;
  struct GSList * * D.29834;
  struct GSList * D.29835;
  unsigned int D.29836;
  int D.29837;
  int D.29838;
  unsigned int D.29839;
  unsigned int D.29840;
  void * D.29841;
  int D.29846;
  void * D.29847;
  int D.29848;
  int * D.29849;
  int j.149;
  unsigned int j.150;
  unsigned int D.29852;
  int * D.29853;
  unsigned int D.29854;
  unsigned int D.29855;
  union mono_mutex_t * D.29858;
  _Bool D.29861;
  long int D.29862;
  long int D.29863;
  void * D.29866;
  struct GHashTable * D.29867;
  struct MonoMethod * D.29868;
  void * D.29869;
  _Bool D.29874;
  long int D.29875;
  long int D.29876;
  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.29762 = cfg->seq_points;
  if (D.29762 == 0B) goto <D.29763>; else goto <D.29764>;
  <D.29763>:
  return;
  <D.29764>:
  D.29762 = cfg->seq_points;
  D.29765 = D.29762->len;
  D.29766 = D.29765 * 20;
  D.29767 = D.29766 + 4;
  info = monoeg_malloc0 (D.29767);
  D.29762 = cfg->seq_points;
  D.29765 = D.29762->len;
  D.29768 = (int) D.29765;
  info->len = D.29768;
  i = 0;
  goto <D.25318>;
  <D.25317>:
  {
    struct SeqPoint * sp;
    struct MonoInst * ins;

    sp = &info->seq_points[i];
    D.29762 = cfg->seq_points;
    D.29769 = D.29762->pdata;
    i.147 = (unsigned int) i;
    D.29771 = i.147 * 4;
    D.29772 = D.29769 + D.29771;
    ins = *D.29772;
    D.29773 = ins->data.op[1].const_val;
    sp->il_offset = D.29773;
    D.29774 = ins->data.op[0].const_val;
    sp->native_offset = D.29774;
    D.29775 = ins->flags;
    D.29776 = (int) D.29775;
    D.29777 = D.29776 & 4;
    if (D.29777 != 0) goto <D.29778>; else goto <D.29779>;
    <D.29778>:
    D.29780 = sp->flags;
    D.29781 = D.29780 | 1;
    sp->flags = D.29781;
    <D.29779>:
    ins->backend.size = i;
  }
  i = i + 1;
  <D.25318>:
  i.148 = (unsigned int) i;
  D.29762 = cfg->seq_points;
  D.29765 = D.29762->len;
  if (i.148 < D.29765) goto <D.25317>; else goto <D.25319>;
  <D.25319>:
  D.29762 = cfg->seq_points;
  D.29765 = D.29762->len;
  D.29783 = D.29765 * 4;
  next = monoeg_malloc0 (D.29783);
  bb = cfg->bb_entry;
  goto <D.25333>;
  <D.25332>:
  D.29784 = bb->seq_points;
  bb_seq_points = monoeg_g_slist_reverse (D.29784);
  last = 0B;
  l = bb_seq_points;
  goto <D.25323>;
  <D.25322>:
  {
    struct MonoInst * ins;

    ins = l->data;
    D.29787 = ins->data.op[1].const_val;
    if (D.29787 == -1) goto <D.29785>; else goto <D.29788>;
    <D.29788>:
    D.29787 = ins->data.op[1].const_val;
    if (D.29787 == 16777215) goto <D.29785>; else goto <D.29786>;
    <D.29785>:
    // predicted unlikely by continue predictor.
    goto <D.25321>;
    <D.29786>:
    D.29789 = ins->data.op[0].const_val;
    if (D.29789 == -1) goto <D.29790>; else goto <D.29791>;
    <D.29790>:
    // predicted unlikely by continue predictor.
    goto <D.25321>;
    <D.29791>:
    if (last != 0B) goto <D.29792>; else goto <D.29793>;
    <D.29792>:
    D.29794 = last->backend.size;
    D.29795 = (unsigned int) D.29794;
    D.29796 = D.29795 * 4;
    D.29797 = next + D.29796;
    D.29794 = last->backend.size;
    D.29795 = (unsigned int) D.29794;
    D.29796 = D.29795 * 4;
    D.29797 = next + D.29796;
    D.29798 = *D.29797;
    D.29799 = ins->backend.size;
    D.29800 = (void *) D.29799;
    D.29801 = monoeg_g_slist_append (D.29798, D.29800);
    *D.29797 = D.29801;
    goto <D.29802>;
    <D.29793>:
    collect_pred_seq_points (bb, ins, next, 0);
    <D.29802>:
    last = ins;
  }
  <D.25321>:
  l = l->next;
  <D.25323>:
  if (l != 0B) goto <D.25322>; else goto <D.25324>;
  <D.25324>:
  D.29803 = bb->last_ins;
  if (D.29803 != 0B) goto <D.29804>; else goto <D.29805>;
  <D.29804>:
  D.29803 = bb->last_ins;
  D.29806 = D.29803->opcode;
  if (D.29806 == 738) goto <D.29807>; else goto <D.29808>;
  <D.29807>:
  D.29784 = bb->seq_points;
  if (D.29784 != 0B) goto <D.29809>; else goto <D.29810>;
  <D.29809>:
  {
    struct MonoBasicBlock * bb2;
    struct MonoInst * endfinally_seq_point;

    endfinally_seq_point = 0B;
    D.29784 = bb->seq_points;
    l = monoeg_g_slist_last (D.29784);
    if (l != 0B) goto <D.29811>; else goto <D.29812>;
    <D.29811>:
    endfinally_seq_point = l->data;
    bb2 = cfg->bb_entry;
    goto <D.25330>;
    <D.25329>:
    {
      struct GSList * l;

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

        ins = l->data;
        D.29816 = ins->data.op[1].const_val;
        if (D.29816 != -1) goto <D.29817>; else goto <D.29818>;
        <D.29817>:
        D.29816 = ins->data.op[1].const_val;
        if (D.29816 != 16777215) goto <D.29819>; else goto <D.29820>;
        <D.29819>:
        if (ins != endfinally_seq_point) goto <D.29821>; else goto <D.29822>;
        <D.29821>:
        D.29823 = endfinally_seq_point->backend.size;
        D.29824 = (unsigned int) D.29823;
        D.29825 = D.29824 * 4;
        D.29826 = next + D.29825;
        D.29823 = endfinally_seq_point->backend.size;
        D.29824 = (unsigned int) D.29823;
        D.29825 = D.29824 * 4;
        D.29826 = next + D.29825;
        D.29827 = *D.29826;
        D.29828 = ins->backend.size;
        D.29829 = (void *) D.29828;
        D.29830 = monoeg_g_slist_append (D.29827, D.29829);
        *D.29826 = D.29830;
        <D.29822>:
        <D.29820>:
        <D.29818>:
      }
      <D.29815>:
    }
    bb2 = bb2->next_bb;
    <D.25330>:
    if (bb2 != 0B) goto <D.25329>; else goto <D.25331>;
    <D.25331>:
    <D.29812>:
  }
  <D.29810>:
  <D.29808>:
  <D.29805>:
  bb = bb->next_bb;
  <D.25333>:
  if (bb != 0B) goto <D.25332>; else goto <D.25334>;
  <D.25334>:
  D.29831 = cfg->verbose_level;
  if (D.29831 > 2) goto <D.29832>; else goto <D.29833>;
  <D.29832>:
  printf ("\nSEQ POINT MAP: \n");
  <D.29833>:
  i = 0;
  goto <D.25346>;
  <D.25345>:
  {
    struct SeqPoint * sp;
    struct GSList * l;
    int j;
    int next_index;

    sp = &info->seq_points[i];
    i.147 = (unsigned int) i;
    D.29771 = i.147 * 4;
    D.29834 = next + D.29771;
    D.29835 = *D.29834;
    D.29836 = monoeg_g_slist_length (D.29835);
    D.29837 = (int) D.29836;
    sp->next_len = D.29837;
    D.29838 = sp->next_len;
    D.29839 = (unsigned int) D.29838;
    D.29840 = D.29839 * 4;
    D.29841 = monoeg_malloc (D.29840);
    sp->next = D.29841;
    j = 0;
    D.29831 = cfg->verbose_level;
    if (D.29831 > 2) goto <D.29842>; else goto <D.29843>;
    <D.29842>:
    i.147 = (unsigned int) i;
    D.29771 = i.147 * 4;
    D.29834 = next + D.29771;
    D.29835 = *D.29834;
    if (D.29835 != 0B) goto <D.29844>; else goto <D.29845>;
    <D.29844>:
    D.29846 = sp->il_offset;
    printf ("\tIL0x%x ->", D.29846);
    i.147 = (unsigned int) i;
    D.29771 = i.147 * 4;
    D.29834 = next + D.29771;
    l = *D.29834;
    goto <D.25340>;
    <D.25339>:
    D.29847 = l->data;
    next_index = (int) D.29847;
    D.29848 = info->seq_points[next_index].il_offset;
    printf (" IL0x%x", D.29848);
    l = l->next;
    <D.25340>:
    if (l != 0B) goto <D.25339>; else goto <D.25341>;
    <D.25341>:
    printf ("\n");
    <D.29845>:
    <D.29843>:
    i.147 = (unsigned int) i;
    D.29771 = i.147 * 4;
    D.29834 = next + D.29771;
    l = *D.29834;
    goto <D.25343>;
    <D.25342>:
    D.29847 = l->data;
    next_index = (int) D.29847;
    D.29849 = sp->next;
    j.149 = j;
    j = j.149 + 1;
    j.150 = (unsigned int) j.149;
    D.29852 = j.150 * 4;
    D.29853 = D.29849 + D.29852;
    *D.29853 = next_index;
    l = l->next;
    <D.25343>:
    if (l != 0B) goto <D.25342>; else goto <D.25344>;
    <D.25344>:
    i.147 = (unsigned int) i;
    D.29771 = i.147 * 4;
    D.29834 = next + D.29771;
    D.29835 = *D.29834;
    monoeg_g_slist_free (D.29835);
  }
  i = i + 1;
  <D.25346>:
  i.148 = (unsigned int) i;
  D.29762 = cfg->seq_points;
  D.29765 = D.29762->len;
  if (i.148 < D.29765) goto <D.25345>; else goto <D.25347>;
  <D.25347>:
  monoeg_g_free (next);
  cfg->seq_point_info = info;
  D.29854 = BIT_FIELD_REF <*cfg, 32, 3392>;
  D.29855 = D.29854 & 64;
  if (D.29855 == 0) goto <D.29856>; else goto <D.29857>;
  <D.29856>:
  {
    int ret;

    D.29858 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.29858);
    if (ret != 0) goto <D.29859>; else goto <D.29860>;
    <D.29859>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29860>:
    D.29861 = ret != 0;
    D.29862 = (long int) D.29861;
    D.29863 = __builtin_expect (D.29862, 0);
    if (D.29863 != 0) goto <D.29864>; else goto <D.29865>;
    <D.29864>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3994, "ret == 0");
    <D.29865>:
  }
  D.29866 = domain->runtime_info;
  D.29867 = MEM[(struct MonoJitDomainInfo *)D.29866].seq_points;
  D.29868 = cfg->method_to_register;
  D.29869 = monoeg_g_hash_table_lookup (D.29867, D.29868);
  if (D.29869 == 0B) goto <D.29870>; else goto <D.29871>;
  <D.29870>:
  D.29866 = domain->runtime_info;
  D.29867 = MEM[(struct MonoJitDomainInfo *)D.29866].seq_points;
  D.29868 = cfg->method_to_register;
  monoeg_g_hash_table_insert_replace (D.29867, D.29868, info, 0);
  <D.29871>:
  {
    int ret;

    D.29858 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.29858);
    if (ret != 0) goto <D.29872>; else goto <D.29873>;
    <D.29872>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29873>:
    D.29874 = ret != 0;
    D.29875 = (long int) D.29874;
    D.29876 = __builtin_expect (D.29875, 0);
    if (D.29876 != 0) goto <D.29877>; else goto <D.29878>;
    <D.29877>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3998, "ret == 0");
    <D.29878>:
  }
  <D.29857>:
  D.29762 = cfg->seq_points;
  monoeg_g_ptr_array_free (D.29762, 1);
  cfg->seq_points = 0B;
}


collect_pred_seq_points (struct MonoBasicBlock * bb, struct MonoInst * ins, struct GSList * * next, int depth)
{
  struct MonoBasicBlock * * D.29880;
  unsigned int i.151;
  unsigned int D.29882;
  struct MonoBasicBlock * * D.29883;
  struct MonoInst * D.29884;
  unsigned int src_index.152;
  unsigned int D.29888;
  struct GSList * * D.29889;
  void * D.29890;
  unsigned int D.29891;
  unsigned int dst_index.153;
  struct GSList * D.29896;
  void * dst_index.154;
  struct GSList * D.29898;
  int D.29902;
  short int D.29903;
  int D.29904;
  int i;
  struct MonoBasicBlock * in_bb;
  struct GSList * l;

  i = 0;
  goto <D.25302>;
  <D.25301>:
  D.29880 = bb->in_bb;
  i.151 = (unsigned int) i;
  D.29882 = i.151 * 4;
  D.29883 = D.29880 + D.29882;
  in_bb = *D.29883;
  D.29884 = in_bb->last_seq_point;
  if (D.29884 != 0B) goto <D.29885>; else goto <D.29886>;
  <D.29885>:
  {
    int src_index;
    int dst_index;

    D.29884 = in_bb->last_seq_point;
    src_index = D.29884->backend.size;
    dst_index = ins->backend.size;
    src_index.152 = (unsigned int) src_index;
    D.29888 = src_index.152 * 4;
    D.29889 = next + D.29888;
    l = *D.29889;
    goto <D.25300>;
    <D.25299>:
    D.29890 = l->data;
    D.29891 = (unsigned int) D.29890;
    dst_index.153 = (unsigned int) dst_index;
    if (D.29891 == dst_index.153) goto <D.25298>; else goto <D.29893>;
    <D.29893>:
    l = l->next;
    <D.25300>:
    if (l != 0B) goto <D.25299>; else goto <D.25298>;
    <D.25298>:
    if (l == 0B) goto <D.29894>; else goto <D.29895>;
    <D.29894>:
    src_index.152 = (unsigned int) src_index;
    D.29888 = src_index.152 * 4;
    D.29889 = next + D.29888;
    src_index.152 = (unsigned int) src_index;
    D.29888 = src_index.152 * 4;
    D.29889 = next + D.29888;
    D.29896 = *D.29889;
    dst_index.154 = (void *) dst_index;
    D.29898 = monoeg_g_slist_append (D.29896, dst_index.154);
    *D.29889 = D.29898;
    <D.29895>:
  }
  goto <D.29899>;
  <D.29886>:
  if (depth <= 4) goto <D.29900>; else goto <D.29901>;
  <D.29900>:
  D.29902 = depth + 1;
  collect_pred_seq_points (in_bb, ins, next, D.29902);
  <D.29901>:
  <D.29899>:
  i = i + 1;
  <D.25302>:
  D.29903 = bb->in_count;
  D.29904 = (int) D.29903;
  if (D.29904 > i) goto <D.25301>; else goto <D.25303>;
  <D.25303>:
}


mono_domain_lookup_shared_generic (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoInternalHashTable * D.29905;
  struct MonoMethod * D.29906;
  unsigned int D.29909;
  unsigned int D.29910;
  int inited.155;
  int lookups.156;
  int lookups.157;
  int failed_lookups.158;
  int failed_lookups.159;
  struct MonoJitInfo * D.29922;
  static gboolean inited = 0;
  static int lookups = 0;
  static int failed_lookups = 0;
  struct MonoJitInfo * ji;

  D.29905 = &domain->jit_code_hash;
  D.29906 = mini_get_shared_method (method);
  ji = mono_internal_hash_table_lookup (D.29905, D.29906);
  if (ji != 0B) goto <D.29907>; else goto <D.29908>;
  <D.29907>:
  D.29909 = BIT_FIELD_REF <*ji, 32, 160>;
  D.29910 = D.29909 & 131072;
  if (D.29910 == 0) goto <D.29911>; else goto <D.29912>;
  <D.29911>:
  ji = 0B;
  <D.29912>:
  <D.29908>:
  inited.155 = inited;
  if (inited.155 == 0) goto <D.29914>; else goto <D.29915>;
  <D.29914>:
  mono_counters_register ("Shared generic lookups", 2048, &lookups);
  mono_counters_register ("Failed shared generic lookups", 2048, &failed_lookups);
  inited = 1;
  <D.29915>:
  lookups.156 = lookups;
  lookups.157 = lookups.156 + 1;
  lookups = lookups.157;
  if (ji == 0B) goto <D.29918>; else goto <D.29919>;
  <D.29918>:
  failed_lookups.158 = failed_lookups;
  failed_lookups.159 = failed_lookups.158 + 1;
  failed_lookups = failed_lookups.159;
  <D.29919>:
  D.29922 = ji;
  return D.29922;
}


mono_enable_jit_map ()
{
  struct FILE * perf_map_file.160;
  int D.29927;
  struct FILE * perf_map_file.161;

  perf_map_file.160 = perf_map_file;
  if (perf_map_file.160 == 0B) goto <D.29925>; else goto <D.29926>;
  <D.29925>:
  {
    char name[64];

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


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

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


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

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


mono_emit_jit_map (struct MonoJitInfo * jinfo)
{
  struct FILE * perf_map_file.164;
  struct MonoMethod * D.29939;
  void * D.29940;
  int D.29941;

  perf_map_file.164 = perf_map_file;
  if (perf_map_file.164 != 0B) goto <D.29937>; else goto <D.29938>;
  <D.29937>:
  {
    char * name;

    D.29939 = jinfo_get_method (jinfo);
    name = mono_method_full_name (D.29939, 1);
    D.29940 = jinfo->code_start;
    D.29941 = jinfo->code_size;
    mono_emit_jit_tramp (D.29940, D.29941, name);
    monoeg_g_free (name);
  }
  <D.29938>:
}


mono_jit_map_is_enabled ()
{
  gboolean D.29942;
  struct FILE * perf_map_file.165;
  _Bool D.29944;

  perf_map_file.165 = perf_map_file;
  D.29944 = perf_map_file.165 != 0B;
  D.29942 = (gboolean) D.29944;
  return D.29942;
}


mono_jit_compile_method (struct MonoMethod * method)
{
  unsigned int default_opt.166;
  unsigned int D.29947;
  struct MonoException * ex.167;
  _Bool D.29951;
  long int D.29952;
  long int D.29953;
  void * D.29956;
  struct MonoException * ex;
  void * code;

  try
    {
      ex = 0B;
      default_opt.166 = default_opt;
      D.29947 = mono_get_optimizations_for_method (method, default_opt.166);
      code = mono_jit_compile_method_with_opt (method, D.29947, &ex);
      if (code == 0B) goto <D.29948>; else goto <D.29949>;
      <D.29948>:
      ex.167 = ex;
      D.29951 = ex.167 == 0B;
      D.29952 = (long int) D.29951;
      D.29953 = __builtin_expect (D.29952, 0);
      if (D.29953 != 0) goto <D.29954>; else goto <D.29955>;
      <D.29954>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6250, "ex");
      <D.29955>:
      ex.167 = ex;
      mono_raise_exception (ex.167);
      <D.29949>:
      D.29956 = code;
      return D.29956;
    }
  finally
    {
      ex = {CLOBBER};
    }
}


mono_jit_compile_method_with_opt (struct MonoMethod * method, guint32 opt, struct MonoException * * ex)
{
  unsigned int D.29959;
  unsigned int D.29960;
  <unnamed type> D.29965;
  void * D.29968;
  _Bool D.29969;
  long int D.29970;
  long int D.29971;
  unsigned int D.29974;
  struct MonoClass * D.29979;
  struct MonoImage * D.29980;
  struct MonoImage * D.29981;
  unsigned int D.29983;
  unsigned int D.29984;
  _Bool D.29990;
  long int D.29991;
  long int D.29992;
  <unnamed type> D.29995;
  unsigned int D.30007;
  unsigned int D.30008;
  int D.30009;
  int D.30010;
  _Bool D.30011;
  long int D.30012;
  long int D.30013;
  _Bool D.30016;
  int D.30017;
  void * D.30020;
  void * D.30021;
  int opt.168;
  struct MonoDomain * D.30028;
  _Bool D.30029;
  long int D.30030;
  long int D.30031;
  _Bool D.30038;
  long int D.30039;
  long int D.30040;
  const void * D.30043;
  _Bool D.30048;
  long int D.30049;
  long int D.30050;
  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.29959 = BIT_FIELD_REF <*method, 32, 160>;
  D.29960 = D.29959 & 124;
  if (D.29960 == 24) goto <D.29961>; else goto <D.29962>;
  <D.29961>:
  winfo = mono_marshal_get_wrapper_info (method);
  <D.29962>:
  if (winfo != 0B) goto <D.29963>; else goto <D.29964>;
  <D.29963>:
  D.29965 = winfo->subtype;
  if (D.29965 == 15) goto <D.29966>; else goto <D.29967>;
  <D.29966>:
  D.29968 = winfo->d.icall.func;
  callinfo = mono_find_jit_icall_by_addr (D.29968);
  D.29969 = callinfo == 0B;
  D.29970 = (long int) D.29969;
  D.29971 = __builtin_expect (D.29970, 0);
  if (D.29971 != 0) goto <D.29972>; else goto <D.29973>;
  <D.29972>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6160, "callinfo");
  <D.29973>:
  opt = opt | 512;
  <D.29967>:
  <D.29964>:
  D.29959 = BIT_FIELD_REF <*method, 32, 160>;
  D.29974 = D.29959 & 512;
  if (D.29974 != 0) goto <D.29975>; else goto <D.29976>;
  <D.29975>:
  opt = opt & 4294966783;
  <D.29976>:
  D.29979 = method->klass;
  D.29980 = D.29979->image;
  D.29981 = mono_get_corlib ();
  if (D.29980 != D.29981) goto <D.29977>; else goto <D.29982>;
  <D.29982>:
  D.29959 = BIT_FIELD_REF <*method, 32, 160>;
  D.29983 = D.29959 & 4096;
  if (D.29983 != 0) goto <D.29977>; else goto <D.29978>;
  <D.29977>:
  opt = opt & 4294966783;
  <D.29978>:
  D.29984 = opt & 512;
  if (D.29984 != 0) goto <D.29985>; else goto <D.29986>;
  <D.29985>:
  target_domain = mono_get_root_domain ();
  goto <D.29987>;
  <D.29986>:
  target_domain = domain;
  <D.29987>:
  D.29959 = BIT_FIELD_REF <*method, 32, 160>;
  D.29960 = D.29959 & 124;
  if (D.29960 == 100) goto <D.29988>; else goto <D.29989>;
  <D.29988>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    D.29990 = info == 0B;
    D.29991 = (long int) D.29990;
    D.29992 = __builtin_expect (D.29991, 0);
    if (D.29992 != 0) goto <D.29993>; else goto <D.29994>;
    <D.29993>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6181, "info");
    <D.29994>:
    D.29995 = info->subtype;
    if (D.29995 == 17) goto <D.29996>; else goto <D.29997>;
    <D.29996>:
    {
      struct MonoGenericContext * ctx;

      ctx = 0B;
      D.29959 = BIT_FIELD_REF <*method, 32, 160>;
      D.29983 = D.29959 & 4096;
      if (D.29983 != 0) goto <D.29998>; else goto <D.29999>;
      <D.29998>:
      ctx = mono_method_get_context (method);
      <D.29999>:
      method = info->d.synchronized_inner.method;
      if (ctx != 0B) goto <D.30000>; else goto <D.30001>;
      <D.30000>:
      method = mono_class_inflate_generic_method (method, ctx);
      <D.30001>:
    }
    <D.29997>:
  }
  <D.29989>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.30002>; else goto <D.30003>;
  <D.30002>:
  if (domain == target_domain) goto <D.30004>; else goto <D.30006>;
  <D.30006>:
  D.30007 = BIT_FIELD_REF <*info, 32, 160>;
  D.30008 = D.30007 & 32768;
  if (D.30008 != 0) goto <D.30004>; else goto <D.30005>;
  <D.30004>:
  {
    struct MonoVTable * vtable;
    struct MonoException * tmpEx;

    D.30009 = mono_jit_stats.methods_lookups;
    D.30010 = D.30009 + 1;
    mono_jit_stats.methods_lookups = D.30010;
    D.29979 = method->klass;
    vtable = mono_class_vtable (domain, D.29979);
    D.30011 = vtable == 0B;
    D.30012 = (long int) D.30011;
    D.30013 = __builtin_expect (D.30012, 0);
    if (D.30013 != 0) goto <D.30014>; else goto <D.30015>;
    <D.30014>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6201, "vtable");
    <D.30015>:
    D.30016 = ex == 0B;
    D.30017 = (int) D.30016;
    tmpEx = mono_runtime_class_init_full (vtable, D.30017);
    if (tmpEx != 0B) goto <D.30018>; else goto <D.30019>;
    <D.30018>:
    *ex = tmpEx;
    D.30020 = 0B;
    return D.30020;
    <D.30019>:
    D.30021 = info->code_start;
    D.30020 = mono_create_ftnptr (target_domain, D.30021);
    return D.30020;
  }
  <D.30005>:
  <D.30003>:
  opt.168 = (int) opt;
  code = mono_jit_compile_method_inner (method, target_domain, opt.168, ex);
  if (code == 0B) goto <D.30023>; else goto <D.30024>;
  <D.30023>:
  D.30020 = 0B;
  return D.30020;
  <D.30024>:
  D.29959 = BIT_FIELD_REF <*method, 32, 160>;
  D.29960 = D.29959 & 124;
  if (D.29960 == 96) goto <D.30025>; else goto <D.30027>;
  <D.30027>:
  D.29959 = BIT_FIELD_REF <*method, 32, 160>;
  D.29960 = D.29959 & 124;
  if (D.29960 == 112) goto <D.30025>; else goto <D.30026>;
  <D.30025>:
  {
    struct MonoDomain * d;

    try
      {
        D.30028 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.30028, code, &d);
        D.30029 = ji == 0B;
        D.30030 = (long int) D.30029;
        D.30031 = __builtin_expect (D.30030, 0);
        if (D.30031 != 0) goto <D.30032>; else goto <D.30033>;
        <D.30032>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6222, "ji");
        <D.30033>:
      }
    finally
      {
        d = {CLOBBER};
      }
  }
  <D.30026>:
  p = mono_create_ftnptr (target_domain, code);
  if (callinfo != 0B) goto <D.30034>; else goto <D.30035>;
  <D.30034>:
  mono_loader_lock ();
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30036>; else goto <D.30037>;
    <D.30036>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30037>:
    D.30038 = ret != 0;
    D.30039 = (long int) D.30038;
    D.30040 = __builtin_expect (D.30039, 0);
    if (D.30040 != 0) goto <D.30041>; else goto <D.30042>;
    <D.30041>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6230, "ret == 0");
    <D.30042>:
  }
  D.30043 = callinfo->wrapper;
  if (D.30043 == 0B) goto <D.30044>; else goto <D.30045>;
  <D.30044>:
  callinfo->wrapper = p;
  mono_register_jit_icall_wrapper (callinfo, p);
  <D.30045>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30046>; else goto <D.30047>;
    <D.30046>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30047>:
    D.30048 = ret != 0;
    D.30049 = (long int) D.30048;
    D.30050 = __builtin_expect (D.30049, 0);
    if (D.30050 != 0) goto <D.30051>; else goto <D.30052>;
    <D.30051>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6235, "ret == 0");
    <D.30052>:
  }
  mono_loader_unlock ();
  <D.30035>:
  D.30020 = p;
  return D.30020;
}


lookup_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.30054;
  _Bool D.30057;
  long int D.30058;
  long int D.30059;
  _Bool D.30064;
  long int D.30065;
  long int D.30066;
  struct MonoJitInfo * D.30069;
  struct MonoJitInfo * info;

  mono_loader_lock ();
  {
    int ret;

    D.30054 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.30054);
    if (ret != 0) goto <D.30055>; else goto <D.30056>;
    <D.30055>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30056>:
    D.30057 = ret != 0;
    D.30058 = (long int) D.30057;
    D.30059 = __builtin_expect (D.30058, 0);
    if (D.30059 != 0) goto <D.30060>; else goto <D.30061>;
    <D.30060>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5750, "ret == 0");
    <D.30061>:
  }
  info = lookup_method_inner (domain, method);
  {
    int ret;

    D.30054 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.30054);
    if (ret != 0) goto <D.30062>; else goto <D.30063>;
    <D.30062>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30063>:
    D.30064 = ret != 0;
    D.30065 = (long int) D.30064;
    D.30066 = __builtin_expect (D.30065, 0);
    if (D.30066 != 0) goto <D.30067>; else goto <D.30068>;
    <D.30067>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5752, "ret == 0");
    <D.30068>:
  }
  mono_loader_unlock ();
  D.30069 = info;
  return D.30069;
}


lookup_method_inner (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoInternalHashTable * D.30071;
  struct MonoJitInfo * D.30074;
  int D.30075;
  struct MonoJitInfo * ji;

  D.30071 = &domain->jit_code_hash;
  ji = mono_internal_hash_table_lookup (D.30071, method);
  if (ji != 0B) goto <D.30072>; else goto <D.30073>;
  <D.30072>:
  D.30074 = ji;
  return D.30074;
  <D.30073>:
  D.30075 = mono_method_is_generic_sharable (method, 0);
  if (D.30075 == 0) goto <D.30076>; else goto <D.30077>;
  <D.30076>:
  D.30074 = 0B;
  return D.30074;
  <D.30077>:
  D.30074 = mono_domain_lookup_shared_generic (domain, method);
  return D.30074;
}


mono_jit_compile_method_inner (struct MonoMethod * method, struct MonoDomain * target_domain, int opt, struct MonoException * * jit_ex)
{
  int D.30079;
  struct MonoMethod * method.169;
  struct MonoClass * D.30083;
  _Bool D.30086;
  long int D.30087;
  long int D.30088;
  void * D.30091;
  short unsigned int D.30094;
  int D.30095;
  int D.30096;
  short unsigned int D.30098;
  int D.30099;
  int D.30100;
  void * D.30101;
  void * D.30106;
  int D.30108;
  char * D.30111;
  struct MonoImage * D.30112;
  char * D.30113;
  int check_for_pending_exc.170;
  void * D.30116;
  struct MonoDomain * D.30119;
  int D.30122;
  struct MonoClass * D.30125;
  struct MonoClass * D.30126;
  char D.30130;
  int D.25705;
  int iftmp.171;
  int D.25704;
  const char[6] * D.30135;
  unsigned char D.30136;
  int D.30137;
  unsigned char D.30138;
  int D.30139;
  const unsigned char * D.30144;
  unsigned char D.30145;
  int D.30146;
  const unsigned char * D.30147;
  unsigned char D.30148;
  int D.30149;
  const unsigned char * D.30154;
  unsigned char D.30155;
  int D.30156;
  const unsigned char * D.30157;
  unsigned char D.30158;
  int D.30159;
  const unsigned char * D.30164;
  unsigned char D.30165;
  int D.30166;
  const unsigned char * D.30167;
  unsigned char D.30168;
  int D.30169;
  _Bool D.30172;
  long int D.30173;
  long int D.30174;
  const void * D.30177;
  int D.25715;
  int iftmp.172;
  int D.25714;
  const char[7] * D.30183;
  unsigned char D.30184;
  int D.30185;
  unsigned char D.30186;
  int D.30187;
  const unsigned char * D.30192;
  unsigned char D.30193;
  int D.30194;
  const unsigned char * D.30195;
  unsigned char D.30196;
  int D.30197;
  const unsigned char * D.30202;
  unsigned char D.30203;
  int D.30204;
  const unsigned char * D.30205;
  unsigned char D.30206;
  int D.30207;
  const unsigned char * D.30212;
  unsigned char D.30213;
  int D.30214;
  const unsigned char * D.30215;
  unsigned char D.30216;
  int D.30217;
  int D.25724;
  int iftmp.173;
  int D.25723;
  const char[12] * D.30225;
  unsigned char D.30226;
  int D.30227;
  unsigned char D.30228;
  int D.30229;
  const unsigned char * D.30234;
  unsigned char D.30235;
  int D.30236;
  const unsigned char * D.30237;
  unsigned char D.30238;
  int D.30239;
  const unsigned char * D.30244;
  unsigned char D.30245;
  int D.30246;
  const unsigned char * D.30247;
  unsigned char D.30248;
  int D.30249;
  const unsigned char * D.30254;
  unsigned char D.30255;
  int D.30256;
  const unsigned char * D.30257;
  unsigned char D.30258;
  int D.30259;
  void * D.30262;
  int D.25733;
  int iftmp.174;
  int D.25732;
  const char[10] * D.30268;
  unsigned char D.30269;
  int D.30270;
  unsigned char D.30271;
  int D.30272;
  const unsigned char * D.30277;
  unsigned char D.30278;
  int D.30279;
  const unsigned char * D.30280;
  unsigned char D.30281;
  int D.30282;
  const unsigned char * D.30287;
  unsigned char D.30288;
  int D.30289;
  const unsigned char * D.30290;
  unsigned char D.30291;
  int D.30292;
  const unsigned char * D.30297;
  unsigned char D.30298;
  int D.30299;
  const unsigned char * D.30300;
  unsigned char D.30301;
  int D.30302;
  void * D.30306;
  struct MonoImage * D.30307;
  struct MonoException * D.30308;
  unsigned int D.30309;
  unsigned int D.30310;
  <unnamed type> D.30313;
  unsigned int D.30314;
  _Bool D.30317;
  struct MonoTrampInfo * in_tinfo.175;
  struct MonoTrampInfo * out_tinfo.176;
  int mono_aot_only.177;
  const char * iftmp.178;
  struct MonoTrampInfo * tinfo.179;
  struct MonoDomain * D.30336;
  struct MonoException * D.30342;
  unsigned int opt.180;
  double D.30344;
  double D.30345;
  double D.30346;
  unsigned int D.30347;
  void * D.30351;
  char * D.30357;
  guint32 * D.30371;
  struct MonoMethod * D.30372;
  void * * D.30373;
  struct MonoDomain * D.30374;
  unsigned int D.30377;
  unsigned int D.30378;
  union mono_mutex_t * D.30381;
  _Bool D.30384;
  long int D.30385;
  long int D.30386;
  union mono_mutex_t * D.30389;
  _Bool D.30392;
  long int D.30393;
  long int D.30394;
  struct MonoDomain * D.30401;
  unsigned int D.30403;
  unsigned int D.30404;
  struct MonoInternalHashTable * D.30407;
  struct MonoJitInfo * D.30408;
  struct MonoMethod * D.30409;
  _Bool D.30412;
  long int D.30413;
  long int D.30414;
  struct MonoGenericSharingContext * D.30417;
  int D.30420;
  long unsigned int D.30423;
  long unsigned int D.30424;
  int D.30425;
  long unsigned int D.30428;
  long unsigned int D.30429;
  _Bool D.30433;
  long int D.30434;
  long int D.30435;
  int D.30438;
  int D.30439;
  int D.30440;
  int D.30441;
  int D.30442;
  int D.30443;
  int D.30444;
  int D.30445;
  int D.30446;
  int D.30447;
  int D.30448;
  int D.30449;
  int D.30450;
  int D.30451;
  int D.30452;
  int D.30453;
  int D.30454;
  int D.30455;
  int D.30456;
  int D.30457;
  int D.30458;
  int D.30459;
  int D.30460;
  int D.30461;
  int D.30462;
  int D.30463;
  int D.30464;
  int D.30465;
  int D.30466;
  void * D.30467;
  struct GHashTable * D.30468;
  void * D.30473;
  _Bool D.30476;
  long int D.30477;
  long int D.30478;
  _Bool D.30483;
  long int D.30484;
  long int D.30485;
  unsigned int D.30488;
  struct MonoMethod * D.30493;
  struct MonoMethod * D.30496;
  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.30079 = opt & 65536;
  if (D.30079 != 0) goto <D.30080>; else goto <D.30081>;
  <D.30080>:
  {
    struct MonoDomain * domain;

    domain = mono_domain_get ();
    method.169 = method;
    D.30083 = method.169->klass;
    mono_class_init (D.30083);
    method.169 = method;
    code = mono_aot_get_method (domain, method.169);
    if (code != 0B) goto <D.30084>; else goto <D.30085>;
    <D.30084>:
    method.169 = method;
    D.30083 = method.169->klass;
    vtable = mono_class_vtable (domain, D.30083);
    D.30086 = vtable == 0B;
    D.30087 = (long int) D.30086;
    D.30088 = __builtin_expect (D.30087, 0);
    if (D.30088 != 0) goto <D.30089>; else goto <D.30090>;
    <D.30089>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5817, "vtable");
    <D.30090>:
    mono_runtime_class_init (vtable);
    D.30091 = code;
    return D.30091;
    <D.30085>:
  }
  <D.30081>:
  method.169 = method;
  D.30094 = method.169->iflags;
  D.30095 = (int) D.30094;
  D.30096 = D.30095 & 4096;
  if (D.30096 != 0) goto <D.30092>; else goto <D.30097>;
  <D.30097>:
  method.169 = method;
  D.30098 = method.169->flags;
  D.30099 = (int) D.30098;
  D.30100 = D.30099 & 8192;
  if (D.30100 != 0) goto <D.30092>; else goto <D.30093>;
  <D.30092>:
  {
    struct MonoMethod * nm;
    struct MonoMethodPInvoke * piinfo;

    piinfo = method;
    D.30101 = piinfo->addr;
    if (D.30101 == 0B) goto <D.30102>; else goto <D.30103>;
    <D.30102>:
    method.169 = method;
    D.30094 = method.169->iflags;
    D.30095 = (int) D.30094;
    D.30096 = D.30095 & 4096;
    if (D.30096 != 0) goto <D.30104>; else goto <D.30105>;
    <D.30104>:
    method.169 = method;
    D.30106 = mono_lookup_internal_call (method.169);
    piinfo->addr = D.30106;
    goto <D.30107>;
    <D.30105>:
    method.169 = method;
    D.30094 = method.169->iflags;
    D.30095 = (int) D.30094;
    D.30108 = D.30095 & 1;
    if (D.30108 != 0) goto <D.30109>; else goto <D.30110>;
    <D.30109>:
    method.169 = method;
    D.30111 = mono_method_full_name (method.169, 1);
    method.169 = method;
    D.30083 = method.169->klass;
    D.30112 = D.30083->image;
    D.30113 = D.30112->name;
    monoeg_g_log (0B, 16, "Method \'%s\' in assembly \'%s\' contains native code that cannot be executed by Mono on this platform. The assembly was probably created using C++/CLI.\n", D.30111, D.30113);
    goto <D.30114>;
    <D.30110>:
    method.169 = method;
    mono_lookup_pinvoke_call (method.169, 0B, 0B);
    <D.30114>:
    <D.30107>:
    <D.30103>:
    method.169 = method;
    check_for_pending_exc.170 = check_for_pending_exc;
    nm = mono_marshal_get_native_wrapper (method.169, check_for_pending_exc.170, 0);
    D.30116 = mono_compile_method (nm);
    code = mono_get_addr_from_ftnptr (D.30116);
    jinfo = mono_jit_info_table_find (target_domain, code);
    if (jinfo == 0B) goto <D.30117>; else goto <D.30118>;
    <D.30117>:
    D.30119 = mono_domain_get ();
    jinfo = mono_jit_info_table_find (D.30119, code);
    <D.30118>:
    if (jinfo != 0B) goto <D.30120>; else goto <D.30121>;
    <D.30120>:
    method.169 = method;
    mono_profiler_method_end_jit (method.169, jinfo, 0);
    <D.30121>:
    D.30091 = code;
    return D.30091;
  }
  <D.30093>:
  method.169 = method;
  D.30094 = method.169->iflags;
  D.30095 = (int) D.30094;
  D.30122 = D.30095 & 3;
  if (D.30122 != 0) goto <D.30123>; else goto <D.30124>;
  <D.30123>:
  {
    const char * name;
    char * full_name;
    char * msg;
    struct MonoMethod * nm;

    method.169 = method;
    name = method.169->name;
    method.169 = method;
    D.30083 = method.169->klass;
    D.30125 = D.30083->parent;
    D.30126 = mono_defaults.multicastdelegate_class;
    if (D.30125 == D.30126) goto <D.30127>; else goto <D.30128>;
    <D.30127>:
    D.30130 = *name;
    if (D.30130 == 46) goto <D.30131>; else goto <D.30129>;
    <D.30131>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.30135 = ".ctor";
        D.30136 = MEM[(const unsigned char *)D.30135];
        D.30137 = (int) D.30136;
        D.30138 = *__s2;
        D.30139 = (int) D.30138;
        __result = D.30137 - D.30139;
        {
          if (__s2_len != 0) goto <D.30140>; else goto <D.30141>;
          <D.30140>:
          if (__result == 0) goto <D.30142>; else goto <D.30143>;
          <D.30142>:
          D.30144 = &MEM[(void *)".ctor" + 1B];
          D.30145 = *D.30144;
          D.30146 = (int) D.30145;
          D.30147 = __s2 + 1;
          D.30148 = *D.30147;
          D.30149 = (int) D.30148;
          __result = D.30146 - D.30149;
          if (__s2_len > 1) goto <D.30150>; else goto <D.30151>;
          <D.30150>:
          if (__result == 0) goto <D.30152>; else goto <D.30153>;
          <D.30152>:
          D.30154 = &MEM[(void *)".ctor" + 2B];
          D.30155 = *D.30154;
          D.30156 = (int) D.30155;
          D.30157 = __s2 + 2;
          D.30158 = *D.30157;
          D.30159 = (int) D.30158;
          __result = D.30156 - D.30159;
          if (__s2_len > 2) goto <D.30160>; else goto <D.30161>;
          <D.30160>:
          if (__result == 0) goto <D.30162>; else goto <D.30163>;
          <D.30162>:
          D.30164 = &MEM[(void *)".ctor" + 3B];
          D.30165 = *D.30164;
          D.30166 = (int) D.30165;
          D.30167 = __s2 + 3;
          D.30168 = *D.30167;
          D.30169 = (int) D.30168;
          __result = D.30166 - D.30169;
          <D.30163>:
          <D.30161>:
          <D.30153>:
          <D.30151>:
          <D.30143>:
          <D.30141>:
        }
        D.25704 = __result;
      }
      iftmp.171 = -D.25704;
      goto <D.30170>;
      <D.30134>:
      iftmp.171 = __builtin_strcmp (name, ".ctor");
      <D.30170>:
      D.25705 = iftmp.171;
    }
    if (D.25705 == 0) goto <D.30171>; else goto <D.30129>;
    <D.30171>:
    {
      struct MonoJitICallInfo * mi;

      mi = mono_find_jit_icall_by_name ("mono_delegate_ctor");
      D.30172 = mi == 0B;
      D.30173 = (long int) D.30172;
      D.30174 = __builtin_expect (D.30173, 0);
      if (D.30174 != 0) goto <D.30175>; else goto <D.30176>;
      <D.30175>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5858, "mi");
      <D.30176>:
      D.30177 = mono_icall_get_wrapper_full (mi, 1);
      D.30091 = mono_get_addr_from_ftnptr (D.30177);
      return D.30091;
    }
    <D.30129>:
    D.30130 = *name;
    if (D.30130 == 73) goto <D.30179>; else goto <D.30178>;
    <D.30179>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.30183 = "Invoke";
        D.30184 = MEM[(const unsigned char *)D.30183];
        D.30185 = (int) D.30184;
        D.30186 = *__s2;
        D.30187 = (int) D.30186;
        __result = D.30185 - D.30187;
        {
          if (__s2_len != 0) goto <D.30188>; else goto <D.30189>;
          <D.30188>:
          if (__result == 0) goto <D.30190>; else goto <D.30191>;
          <D.30190>:
          D.30192 = &MEM[(void *)"Invoke" + 1B];
          D.30193 = *D.30192;
          D.30194 = (int) D.30193;
          D.30195 = __s2 + 1;
          D.30196 = *D.30195;
          D.30197 = (int) D.30196;
          __result = D.30194 - D.30197;
          if (__s2_len > 1) goto <D.30198>; else goto <D.30199>;
          <D.30198>:
          if (__result == 0) goto <D.30200>; else goto <D.30201>;
          <D.30200>:
          D.30202 = &MEM[(void *)"Invoke" + 2B];
          D.30203 = *D.30202;
          D.30204 = (int) D.30203;
          D.30205 = __s2 + 2;
          D.30206 = *D.30205;
          D.30207 = (int) D.30206;
          __result = D.30204 - D.30207;
          if (__s2_len > 2) goto <D.30208>; else goto <D.30209>;
          <D.30208>:
          if (__result == 0) goto <D.30210>; else goto <D.30211>;
          <D.30210>:
          D.30212 = &MEM[(void *)"Invoke" + 3B];
          D.30213 = *D.30212;
          D.30214 = (int) D.30213;
          D.30215 = __s2 + 3;
          D.30216 = *D.30215;
          D.30217 = (int) D.30216;
          __result = D.30214 - D.30217;
          <D.30211>:
          <D.30209>:
          <D.30201>:
          <D.30199>:
          <D.30191>:
          <D.30189>:
        }
        D.25714 = __result;
      }
      iftmp.172 = -D.25714;
      goto <D.30218>;
      <D.30182>:
      iftmp.172 = __builtin_strcmp (name, "Invoke");
      <D.30218>:
      D.25715 = iftmp.172;
    }
    if (D.25715 == 0) goto <D.30219>; else goto <D.30178>;
    <D.30219>:
    method.169 = method;
    D.30083 = method.169->klass;
    D.30091 = mono_create_delegate_trampoline (target_domain, D.30083);
    return D.30091;
    <D.30178>:
    D.30130 = *name;
    if (D.30130 == 66) goto <D.30221>; else goto <D.30220>;
    <D.30221>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.30225 = "BeginInvoke";
        D.30226 = MEM[(const unsigned char *)D.30225];
        D.30227 = (int) D.30226;
        D.30228 = *__s2;
        D.30229 = (int) D.30228;
        __result = D.30227 - D.30229;
        {
          if (__s2_len != 0) goto <D.30230>; else goto <D.30231>;
          <D.30230>:
          if (__result == 0) goto <D.30232>; else goto <D.30233>;
          <D.30232>:
          D.30234 = &MEM[(void *)"BeginInvoke" + 1B];
          D.30235 = *D.30234;
          D.30236 = (int) D.30235;
          D.30237 = __s2 + 1;
          D.30238 = *D.30237;
          D.30239 = (int) D.30238;
          __result = D.30236 - D.30239;
          if (__s2_len > 1) goto <D.30240>; else goto <D.30241>;
          <D.30240>:
          if (__result == 0) goto <D.30242>; else goto <D.30243>;
          <D.30242>:
          D.30244 = &MEM[(void *)"BeginInvoke" + 2B];
          D.30245 = *D.30244;
          D.30246 = (int) D.30245;
          D.30247 = __s2 + 2;
          D.30248 = *D.30247;
          D.30249 = (int) D.30248;
          __result = D.30246 - D.30249;
          if (__s2_len > 2) goto <D.30250>; else goto <D.30251>;
          <D.30250>:
          if (__result == 0) goto <D.30252>; else goto <D.30253>;
          <D.30252>:
          D.30254 = &MEM[(void *)"BeginInvoke" + 3B];
          D.30255 = *D.30254;
          D.30256 = (int) D.30255;
          D.30257 = __s2 + 3;
          D.30258 = *D.30257;
          D.30259 = (int) D.30258;
          __result = D.30256 - D.30259;
          <D.30253>:
          <D.30251>:
          <D.30243>:
          <D.30241>:
          <D.30233>:
          <D.30231>:
        }
        D.25723 = __result;
      }
      iftmp.173 = -D.25723;
      goto <D.30260>;
      <D.30224>:
      iftmp.173 = __builtin_strcmp (name, "BeginInvoke");
      <D.30260>:
      D.25724 = iftmp.173;
    }
    if (D.25724 == 0) goto <D.30261>; else goto <D.30220>;
    <D.30261>:
    method.169 = method;
    nm = mono_marshal_get_delegate_begin_invoke (method.169);
    D.30262 = mono_compile_method (nm);
    D.30091 = mono_get_addr_from_ftnptr (D.30262);
    return D.30091;
    <D.30220>:
    D.30130 = *name;
    if (D.30130 == 69) goto <D.30263>; else goto <D.30264>;
    <D.30263>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.30268 = "EndInvoke";
        D.30269 = MEM[(const unsigned char *)D.30268];
        D.30270 = (int) D.30269;
        D.30271 = *__s2;
        D.30272 = (int) D.30271;
        __result = D.30270 - D.30272;
        {
          if (__s2_len != 0) goto <D.30273>; else goto <D.30274>;
          <D.30273>:
          if (__result == 0) goto <D.30275>; else goto <D.30276>;
          <D.30275>:
          D.30277 = &MEM[(void *)"EndInvoke" + 1B];
          D.30278 = *D.30277;
          D.30279 = (int) D.30278;
          D.30280 = __s2 + 1;
          D.30281 = *D.30280;
          D.30282 = (int) D.30281;
          __result = D.30279 - D.30282;
          if (__s2_len > 1) goto <D.30283>; else goto <D.30284>;
          <D.30283>:
          if (__result == 0) goto <D.30285>; else goto <D.30286>;
          <D.30285>:
          D.30287 = &MEM[(void *)"EndInvoke" + 2B];
          D.30288 = *D.30287;
          D.30289 = (int) D.30288;
          D.30290 = __s2 + 2;
          D.30291 = *D.30290;
          D.30292 = (int) D.30291;
          __result = D.30289 - D.30292;
          if (__s2_len > 2) goto <D.30293>; else goto <D.30294>;
          <D.30293>:
          if (__result == 0) goto <D.30295>; else goto <D.30296>;
          <D.30295>:
          D.30297 = &MEM[(void *)"EndInvoke" + 3B];
          D.30298 = *D.30297;
          D.30299 = (int) D.30298;
          D.30300 = __s2 + 3;
          D.30301 = *D.30300;
          D.30302 = (int) D.30301;
          __result = D.30299 - D.30302;
          <D.30296>:
          <D.30294>:
          <D.30286>:
          <D.30284>:
          <D.30276>:
          <D.30274>:
        }
        D.25732 = __result;
      }
      iftmp.174 = -D.25732;
      goto <D.30303>;
      <D.30267>:
      iftmp.174 = __builtin_strcmp (name, "EndInvoke");
      <D.30303>:
      D.25733 = iftmp.174;
    }
    if (D.25733 == 0) goto <D.30304>; else goto <D.30305>;
    <D.30304>:
    method.169 = method;
    nm = mono_marshal_get_delegate_end_invoke (method.169);
    D.30306 = mono_compile_method (nm);
    D.30091 = mono_get_addr_from_ftnptr (D.30306);
    return D.30091;
    <D.30305>:
    <D.30264>:
    <D.30128>:
    method.169 = method;
    full_name = mono_method_full_name (method.169, 1);
    msg = monoeg_g_strdup_printf ("Unrecognizable runtime implemented method \'%s\'", full_name);
    D.30307 = mono_defaults.corlib;
    D.30308 = mono_exception_from_name_msg (D.30307, "System", "InvalidProgramException", msg);
    *jit_ex = D.30308;
    monoeg_g_free (full_name);
    monoeg_g_free (msg);
    D.30091 = 0B;
    return D.30091;
  }
  <D.30124>:
  method.169 = method;
  D.30309 = BIT_FIELD_REF <*method.169, 32, 160>;
  D.30310 = D.30309 & 124;
  if (D.30310 == 100) goto <D.30311>; else goto <D.30312>;
  <D.30311>:
  {
    struct WrapperInfo * info;

    method.169 = method;
    info = mono_marshal_get_wrapper_info (method.169);
    D.30313 = info->subtype;
    D.30314 = D.30313 + 4294967278;
    if (D.30314 <= 1) goto <D.30315>; else goto <D.30316>;
    <D.30315>:
    {
      static struct MonoTrampInfo * in_tinfo;
      static struct MonoTrampInfo * out_tinfo;
      struct MonoTrampInfo * tinfo;
      struct MonoJitInfo * jinfo;
      gboolean is_in;

      try
        {
          D.30313 = info->subtype;
          D.30317 = D.30313 == 18;
          is_in = (gboolean) D.30317;
          if (is_in != 0) goto <D.30319>; else goto <D.30318>;
          <D.30319>:
          in_tinfo.175 = in_tinfo;
          if (in_tinfo.175 != 0B) goto <D.30321>; else goto <D.30318>;
          <D.30321>:
          in_tinfo.175 = in_tinfo;
          D.30091 = in_tinfo.175->code;
          return D.30091;
          <D.30318>:
          if (is_in == 0) goto <D.30322>; else goto <D.30323>;
          <D.30322>:
          out_tinfo.176 = out_tinfo;
          if (out_tinfo.176 != 0B) goto <D.30325>; else goto <D.30326>;
          <D.30325>:
          out_tinfo.176 = out_tinfo;
          D.30091 = out_tinfo.176->code;
          return D.30091;
          <D.30326>:
          <D.30323>:
          mono_aot_only.177 = mono_aot_only;
          if (mono_aot_only.177 != 0) goto <D.30328>; else goto <D.30329>;
          <D.30328>:
          if (is_in != 0) goto <D.30331>; else goto <D.30332>;
          <D.30331>:
          iftmp.178 = "gsharedvt_trampoline";
          goto <D.30333>;
          <D.30332>:
          iftmp.178 = "gsharedvt_out_trampoline";
          <D.30333>:
          mono_aot_get_trampoline_full (iftmp.178, &tinfo);
          goto <D.30334>;
          <D.30329>:
          mono_arch_get_gsharedvt_trampoline (&tinfo, 0);
          <D.30334>:
          method.169 = method;
          tinfo.179 = tinfo;
          jinfo = create_jit_info_for_trampoline (method.169, tinfo.179);
          D.30336 = mono_get_root_domain ();
          mono_jit_info_table_add (D.30336, jinfo);
          if (is_in != 0) goto <D.30337>; else goto <D.30338>;
          <D.30337>:
          tinfo.179 = tinfo;
          in_tinfo = tinfo.179;
          goto <D.30339>;
          <D.30338>:
          tinfo.179 = tinfo;
          out_tinfo = tinfo.179;
          <D.30339>:
          tinfo.179 = tinfo;
          D.30091 = tinfo.179->code;
          return D.30091;
        }
      finally
        {
          tinfo = {CLOBBER};
        }
    }
    <D.30316>:
  }
  <D.30312>:
  mono_aot_only.177 = mono_aot_only;
  if (mono_aot_only.177 != 0) goto <D.30340>; else goto <D.30341>;
  <D.30340>:
  {
    char * fullname;
    char * msg;

    method.169 = method;
    fullname = mono_method_full_name (method.169, 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.30342 = mono_get_exception_execution_engine (msg);
    *jit_ex = D.30342;
    monoeg_g_free (fullname);
    monoeg_g_free (msg);
    D.30091 = 0B;
    return D.30091;
  }
  <D.30341>:
  jit_timer = monoeg_g_timer_new ();
  method.169 = method;
  opt.180 = (unsigned int) opt;
  cfg = mini_method_compile (method.169, opt.180, target_domain, 1, 0);
  prof_method = cfg->method;
  monoeg_g_timer_stop (jit_timer);
  D.30344 = monoeg_g_timer_elapsed (jit_timer, 0B);
  D.30345 = mono_jit_stats.jit_time;
  D.30346 = D.30345 + D.30344;
  mono_jit_stats.jit_time = D.30346;
  monoeg_g_timer_destroy (jit_timer);
  D.30347 = cfg->exception_type;
  switch (D.30347) <default: <D.25761>, case 0: <D.25742>, case 1: <D.25754>, case 3: <D.25750>, case 4: <D.25751>, case 5: <D.25746>, case 6: <D.25745>, case 7: <D.25744>, case 8: <D.25747>, case 9: <D.25752>, case 10: <D.25753>, case 12: <D.25748>, case 13: <D.25758>, case 14: <D.25760>>
  <D.25742>:
  goto <D.25743>;
  <D.25744>:
  <D.25745>:
  <D.25746>:
  <D.25747>:
  <D.25748>:
  {
    struct MonoLoaderError * error;

    error = mono_loader_get_last_error ();
    if (error != 0B) goto <D.30348>; else goto <D.30349>;
    <D.30348>:
    ex = mono_loader_error_prepare_exception (error);
    goto <D.30350>;
    <D.30349>:
    D.30351 = cfg->exception_ptr;
    if (D.30351 != 0B) goto <D.30352>; else goto <D.30353>;
    <D.30352>:
    D.30351 = cfg->exception_ptr;
    ex = mono_class_get_exception_for_failure (D.30351);
    goto <D.30354>;
    <D.30353>:
    D.30347 = cfg->exception_type;
    if (D.30347 == 6) goto <D.30355>; else goto <D.30356>;
    <D.30355>:
    D.30307 = mono_defaults.corlib;
    D.30357 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.30307, "System", "MissingFieldException", D.30357);
    goto <D.30358>;
    <D.30356>:
    D.30347 = cfg->exception_type;
    if (D.30347 == 5) goto <D.30359>; else goto <D.30360>;
    <D.30359>:
    D.30307 = mono_defaults.corlib;
    D.30357 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.30307, "System", "MissingMethodException", D.30357);
    goto <D.30361>;
    <D.30360>:
    D.30347 = cfg->exception_type;
    if (D.30347 == 7) goto <D.30362>; else goto <D.30363>;
    <D.30362>:
    D.30307 = mono_defaults.corlib;
    D.30357 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.30307, "System", "TypeLoadException", D.30357);
    goto <D.30364>;
    <D.30363>:
    D.30347 = cfg->exception_type;
    if (D.30347 == 8) goto <D.30365>; else goto <D.30366>;
    <D.30365>:
    D.30307 = mono_defaults.corlib;
    D.30357 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.30307, "System", "FileNotFoundException", D.30357);
    goto <D.30367>;
    <D.30366>:
    D.30347 = cfg->exception_type;
    if (D.30347 == 12) goto <D.30368>; else goto <D.30369>;
    <D.30368>:
    D.30357 = cfg->exception_message;
    ex = mono_get_exception_bad_image_format (D.30357);
    goto <D.30370>;
    <D.30369>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 5975);
    <D.30370>:
    <D.30367>:
    <D.30364>:
    <D.30361>:
    <D.30358>:
    <D.30354>:
    <D.30350>:
    goto <D.25743>;
  }
  <D.25750>:
  D.30307 = mono_defaults.corlib;
  D.30357 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.30307, "System", "InvalidProgramException", D.30357);
  goto <D.25743>;
  <D.25751>:
  D.30307 = mono_defaults.corlib;
  D.30357 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.30307, "System.Security", "VerificationException", D.30357);
  goto <D.25743>;
  <D.25752>:
  D.30307 = mono_defaults.corlib;
  D.30357 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.30307, "System", "MethodAccessException", D.30357);
  goto <D.25743>;
  <D.25753>:
  D.30307 = mono_defaults.corlib;
  D.30357 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.30307, "System", "FieldAccessException", D.30357);
  goto <D.25743>;
  <D.25754>:
  {
    struct MonoSecurityManager * secman;
    struct MonoObject * exc;
    void * args[2];

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

    exp = cfg->exception_ptr;
    D.30373 = &cfg->exception_ptr;
    mono_gc_deregister_root (D.30373);
    ex = exp;
    goto <D.25743>;
  }
  <D.25760>:
  D.30374 = mono_domain_get ();
  ex = D.30374->out_of_memory_ex;
  goto <D.25743>;
  <D.25761>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 6018);
  <D.25743>:
  if (ex != 0B) goto <D.30375>; else goto <D.30376>;
  <D.30375>:
  D.30377 = cfg->prof_options;
  D.30378 = D.30377 & 16;
  if (D.30378 != 0) goto <D.30379>; else goto <D.30380>;
  <D.30379>:
  method.169 = method;
  mono_profiler_method_end_jit (method.169, 0B, 1);
  <D.30380>:
  mono_destroy_compile (cfg);
  *jit_ex = ex;
  D.30091 = 0B;
  return D.30091;
  <D.30376>:
  mono_loader_lock ();
  {
    int ret;

    D.30381 = &target_domain->lock.mutex;
    ret = pthread_mutex_lock (D.30381);
    if (ret != 0) goto <D.30382>; else goto <D.30383>;
    <D.30382>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30383>:
    D.30384 = ret != 0;
    D.30385 = (long int) D.30384;
    D.30386 = __builtin_expect (D.30385, 0);
    if (D.30386 != 0) goto <D.30387>; else goto <D.30388>;
    <D.30387>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6032, "ret == 0");
    <D.30388>:
  }
  {
    int ret;

    D.30389 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.30389);
    if (ret != 0) goto <D.30390>; else goto <D.30391>;
    <D.30390>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30391>:
    D.30392 = ret != 0;
    D.30393 = (long int) D.30392;
    D.30394 = __builtin_expect (D.30393, 0);
    if (D.30394 != 0) goto <D.30395>; else goto <D.30396>;
    <D.30395>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6037, "ret == 0");
    <D.30396>:
  }
  method.169 = method;
  info = lookup_method_inner (target_domain, method.169);
  if (info != 0B) goto <D.30397>; else goto <D.30398>;
  <D.30397>:
  D.30401 = mono_domain_get ();
  if (D.30401 == target_domain) goto <D.30399>; else goto <D.30402>;
  <D.30402>:
  D.30403 = BIT_FIELD_REF <*info, 32, 160>;
  D.30404 = D.30403 & 32768;
  if (D.30404 != 0) goto <D.30399>; else goto <D.30400>;
  <D.30399>:
  code = info->code_start;
  <D.30400>:
  <D.30398>:
  if (code == 0B) goto <D.30405>; else goto <D.30406>;
  <D.30405>:
  D.30407 = &target_domain->jit_code_hash;
  D.30408 = cfg->jit_info;
  D.30409 = D.30408->d.method;
  D.30408 = cfg->jit_info;
  mono_internal_hash_table_insert (D.30407, D.30409, D.30408);
  {
    int ret;

    D.30389 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.30389);
    if (ret != 0) goto <D.30410>; else goto <D.30411>;
    <D.30410>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30411>:
    D.30412 = ret != 0;
    D.30413 = (long int) D.30412;
    D.30414 = __builtin_expect (D.30413, 0);
    if (D.30414 != 0) goto <D.30415>; else goto <D.30416>;
    <D.30415>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6050, "ret == 0");
    <D.30416>:
  }
  code = cfg->native_code;
  D.30417 = cfg->generic_sharing_context;
  if (D.30417 != 0B) goto <D.30418>; else goto <D.30419>;
  <D.30418>:
  method.169 = method;
  D.30420 = mono_method_is_generic_sharable (method.169, 0);
  if (D.30420 != 0) goto <D.30421>; else goto <D.30422>;
  <D.30421>:
  D.30423 = mono_stats.generics_shared_methods;
  D.30424 = D.30423 + 1;
  mono_stats.generics_shared_methods = D.30424;
  <D.30422>:
  <D.30419>:
  D.30425 = cfg->gsharedvt;
  if (D.30425 != 0) goto <D.30426>; else goto <D.30427>;
  <D.30426>:
  D.30428 = mono_stats.gsharedvt_methods;
  D.30429 = D.30428 + 1;
  mono_stats.gsharedvt_methods = D.30429;
  <D.30427>:
  goto <D.30430>;
  <D.30406>:
  {
    int ret;

    D.30389 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.30389);
    if (ret != 0) goto <D.30431>; else goto <D.30432>;
    <D.30431>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30432>:
    D.30433 = ret != 0;
    D.30434 = (long int) D.30433;
    D.30435 = __builtin_expect (D.30434, 0);
    if (D.30435 != 0) goto <D.30436>; else goto <D.30437>;
    <D.30436>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6058, "ret == 0");
    <D.30437>:
  }
  <D.30430>:
  jinfo = cfg->jit_info;
  prof_options = cfg->prof_options;
  D.30438 = mono_jit_stats.allocate_var;
  D.30439 = cfg->stat_allocate_var;
  D.30440 = D.30438 + D.30439;
  mono_jit_stats.allocate_var = D.30440;
  D.30441 = mono_jit_stats.locals_stack_size;
  D.30442 = cfg->stat_locals_stack_size;
  D.30443 = D.30441 + D.30442;
  mono_jit_stats.locals_stack_size = D.30443;
  D.30444 = mono_jit_stats.basic_blocks;
  D.30445 = cfg->stat_basic_blocks;
  D.30446 = D.30444 + D.30445;
  mono_jit_stats.basic_blocks = D.30446;
  D.30447 = mono_jit_stats.max_basic_blocks;
  D.30445 = cfg->stat_basic_blocks;
  D.30448 = MAX_EXPR <D.30447, D.30445>;
  mono_jit_stats.max_basic_blocks = D.30448;
  D.30449 = mono_jit_stats.cil_code_size;
  D.30450 = cfg->stat_cil_code_size;
  D.30451 = D.30449 + D.30450;
  mono_jit_stats.cil_code_size = D.30451;
  D.30452 = mono_jit_stats.regvars;
  D.30453 = cfg->stat_n_regvars;
  D.30454 = D.30452 + D.30453;
  mono_jit_stats.regvars = D.30454;
  D.30455 = mono_jit_stats.inlineable_methods;
  D.30456 = cfg->stat_inlineable_methods;
  D.30457 = D.30455 + D.30456;
  mono_jit_stats.inlineable_methods = D.30457;
  D.30458 = mono_jit_stats.inlined_methods;
  D.30459 = cfg->stat_inlined_methods;
  D.30460 = D.30458 + D.30459;
  mono_jit_stats.inlined_methods = D.30460;
  D.30461 = mono_jit_stats.cas_demand_generation;
  D.30462 = cfg->stat_cas_demand_generation;
  D.30463 = D.30461 + D.30462;
  mono_jit_stats.cas_demand_generation = D.30463;
  D.30464 = mono_jit_stats.code_reallocs;
  D.30465 = cfg->stat_code_reallocs;
  D.30466 = D.30464 + D.30465;
  mono_jit_stats.code_reallocs = D.30466;
  mono_destroy_compile (cfg);
  D.30467 = target_domain->runtime_info;
  D.30468 = MEM[(struct MonoJitDomainInfo *)D.30467].jump_target_hash;
  if (D.30468 != 0B) goto <D.30469>; else goto <D.30470>;
  <D.30469>:
  {
    struct MonoJumpInfo patch_info;
    struct MonoJumpList * jlist;
    struct GSList * tmp;

    try
      {
        D.30467 = target_domain->runtime_info;
        D.30468 = MEM[(struct MonoJitDomainInfo *)D.30467].jump_target_hash;
        method.169 = method;
        jlist = monoeg_g_hash_table_lookup (D.30468, method.169);
        if (jlist != 0B) goto <D.30471>; else goto <D.30472>;
        <D.30471>:
        patch_info.next = 0B;
        patch_info.ip.i = 0;
        patch_info.type = 4;
        method.169 = method;
        patch_info.data.method = method.169;
        D.30467 = target_domain->runtime_info;
        D.30468 = MEM[(struct MonoJitDomainInfo *)D.30467].jump_target_hash;
        method.169 = method;
        monoeg_g_hash_table_remove (D.30468, method.169);
        tmp = jlist->list;
        goto <D.25770>;
        <D.25769>:
        D.30473 = tmp->data;
        mono_arch_patch_code (0B, target_domain, D.30473, &patch_info, 0B, 1);
        tmp = tmp->next;
        <D.25770>:
        if (tmp != 0B) goto <D.25769>; else goto <D.25771>;
        <D.25771>:
        <D.30472>:
      }
    finally
      {
        patch_info = {CLOBBER};
      }
  }
  <D.30470>:
  mono_emit_jit_map (jinfo);
  {
    int ret;

    D.30381 = &target_domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30381);
    if (ret != 0) goto <D.30474>; else goto <D.30475>;
    <D.30474>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30475>:
    D.30476 = ret != 0;
    D.30477 = (long int) D.30476;
    D.30478 = __builtin_expect (D.30477, 0);
    if (D.30478 != 0) goto <D.30479>; else goto <D.30480>;
    <D.30479>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6109, "ret == 0");
    <D.30480>:
  }
  mono_loader_unlock ();
  method.169 = method;
  D.30083 = method.169->klass;
  vtable = mono_class_vtable (target_domain, D.30083);
  if (vtable == 0B) goto <D.30481>; else goto <D.30482>;
  <D.30481>:
  method.169 = method;
  D.30083 = method.169->klass;
  ex = mono_class_get_exception_for_failure (D.30083);
  D.30483 = ex == 0B;
  D.30484 = (long int) D.30483;
  D.30485 = __builtin_expect (D.30484, 0);
  if (D.30485 != 0) goto <D.30486>; else goto <D.30487>;
  <D.30486>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6115, "ex");
  <D.30487>:
  *jit_ex = ex;
  D.30091 = 0B;
  return D.30091;
  <D.30482>:
  D.30488 = prof_options & 16;
  if (D.30488 != 0) goto <D.30489>; else goto <D.30490>;
  <D.30489>:
  method.169 = method;
  D.30309 = BIT_FIELD_REF <*method.169, 32, 160>;
  D.30310 = D.30309 & 124;
  if (D.30310 == 24) goto <D.30491>; else goto <D.30492>;
  <D.30491>:
  method.169 = method;
  D.30493 = mono_marshal_method_from_wrapper (method.169);
  if (D.30493 != 0B) goto <D.30494>; else goto <D.30495>;
  <D.30494>:
  method.169 = method;
  D.30496 = mono_marshal_method_from_wrapper (method.169);
  mono_profiler_method_end_jit (D.30496, jinfo, 0);
  <D.30495>:
  <D.30492>:
  method.169 = method;
  mono_profiler_method_end_jit (method.169, jinfo, 0);
  method.169 = method;
  if (prof_method != method.169) goto <D.30497>; else goto <D.30498>;
  <D.30497>:
  mono_profiler_method_end_jit (prof_method, jinfo, 0);
  <D.30498>:
  <D.30490>:
  ex = mono_runtime_class_init_full (vtable, 0);
  if (ex != 0B) goto <D.30499>; else goto <D.30500>;
  <D.30499>:
  *jit_ex = ex;
  D.30091 = 0B;
  return D.30091;
  <D.30500>:
  D.30091 = code;
  return D.30091;
}


create_jit_info_for_trampoline (struct MonoMethod * wrapper, struct MonoTrampInfo * info)
{
  guint8 * D.30505;
  unsigned int info_len.181;
  struct GSList * D.30510;
  guint8 * D.30511;
  unsigned int D.30512;
  int D.30513;
  unsigned int info_len.182;
  unsigned int D.30515;
  struct MonoJitInfo * D.30516;
  struct MonoDomain * domain;
  struct MonoJitInfo * jinfo;
  guint8 * uw_info;
  guint32 info_len;

  try
    {
      domain = mono_get_root_domain ();
      D.30505 = info->uw_info;
      if (D.30505 != 0B) goto <D.30506>; else goto <D.30507>;
      <D.30506>:
      uw_info = info->uw_info;
      info_len.181 = info->uw_info_len;
      info_len = info_len.181;
      goto <D.30509>;
      <D.30507>:
      D.30510 = info->unwind_ops;
      uw_info = mono_unwind_ops_encode (D.30510, &info_len);
      <D.30509>:
      jinfo = mono_domain_alloc0 (domain, 28);
      jinfo->d.method = wrapper;
      D.30511 = info->code;
      jinfo->code_start = D.30511;
      D.30512 = info->code_size;
      D.30513 = (int) D.30512;
      jinfo->code_size = D.30513;
      info_len.182 = info_len;
      D.30515 = mono_cache_unwind_info (uw_info, info_len.182);
      jinfo->used_regs = D.30515;
      D.30516 = jinfo;
      return D.30516;
    }
  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.183;
  unsigned int D.30520;
  unsigned int D.30529;
  unsigned int D.30530;
  int D.30531;
  int D.30532;
  void * D.30535;
  struct MonoDomain * target_domain;
  struct MonoJitInfo * info;

  default_opt.183 = default_opt;
  D.30520 = default_opt.183 & 512;
  if (D.30520 != 0) goto <D.30521>; else goto <D.30522>;
  <D.30521>:
  target_domain = mono_get_root_domain ();
  goto <D.30523>;
  <D.30522>:
  target_domain = domain;
  <D.30523>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.30524>; else goto <D.30525>;
  <D.30524>:
  if (domain == target_domain) goto <D.30526>; else goto <D.30528>;
  <D.30528>:
  D.30529 = BIT_FIELD_REF <*info, 32, 160>;
  D.30530 = D.30529 & 32768;
  if (D.30530 != 0) goto <D.30526>; else goto <D.30527>;
  <D.30526>:
  D.30531 = mono_jit_stats.methods_lookups;
  D.30532 = D.30531 + 1;
  mono_jit_stats.methods_lookups = D.30532;
  if (ji != 0B) goto <D.30533>; else goto <D.30534>;
  <D.30533>:
  *ji = info;
  <D.30534>:
  D.30535 = info->code_start;
  return D.30535;
  <D.30527>:
  <D.30525>:
  if (ji != 0B) goto <D.30536>; else goto <D.30537>;
  <D.30536>:
  *ji = 0B;
  <D.30537>:
  D.30535 = 0B;
  return D.30535;
}


mono_get_optimizations_for_method (struct MonoMethod * method, guint32 default_opt)
{
  _Bool D.30539;
  long int D.30540;
  long int D.30541;
  int mono_do_single_method_regression.184;
  guint32 D.30547;
  struct MonoMethod * mono_current_single_method.185;
  struct GHashTable * mono_single_method_hash.186;
  struct GHashTable * mono_single_method_hash.187;
  void * D.30555;
  struct GSList * mono_single_method_list.188;
  struct GSList * mono_single_method_list.189;

  D.30539 = method == 0B;
  D.30540 = (long int) D.30539;
  D.30541 = __builtin_expect (D.30540, 0);
  if (D.30541 != 0) goto <D.30542>; else goto <D.30543>;
  <D.30542>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6380, "method");
  <D.30543>:
  mono_do_single_method_regression.184 = mono_do_single_method_regression;
  if (mono_do_single_method_regression.184 == 0) goto <D.30545>; else goto <D.30546>;
  <D.30545>:
  D.30547 = default_opt;
  return D.30547;
  <D.30546>:
  mono_current_single_method.185 = mono_current_single_method;
  if (mono_current_single_method.185 == 0B) goto <D.30549>; else goto <D.30550>;
  <D.30549>:
  mono_single_method_hash.186 = mono_single_method_hash;
  if (mono_single_method_hash.186 == 0B) goto <D.30552>; else goto <D.30553>;
  <D.30552>:
  mono_single_method_hash.187 = monoeg_g_hash_table_new (monoeg_g_direct_hash, monoeg_g_direct_equal);
  mono_single_method_hash = mono_single_method_hash.187;
  <D.30553>:
  mono_single_method_hash.186 = mono_single_method_hash;
  D.30555 = monoeg_g_hash_table_lookup (mono_single_method_hash.186, method);
  if (D.30555 == 0B) goto <D.30556>; else goto <D.30557>;
  <D.30556>:
  mono_single_method_hash.186 = mono_single_method_hash;
  monoeg_g_hash_table_insert_replace (mono_single_method_hash.186, method, method, 0);
  mono_single_method_list.188 = mono_single_method_list;
  mono_single_method_list.189 = monoeg_g_slist_prepend (mono_single_method_list.188, method);
  mono_single_method_list = mono_single_method_list.189;
  <D.30557>:
  D.30547 = default_opt;
  return D.30547;
  <D.30550>:
  mono_current_single_method.185 = mono_current_single_method;
  if (method == mono_current_single_method.185) goto <D.30560>; else goto <D.30561>;
  <D.30560>:
  D.30547 = mono_single_method_regression_opt;
  return D.30547;
  <D.30561>:
  D.30547 = default_opt;
  return D.30547;
}


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

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


mono_sigfpe_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  struct MonoDomain * D.30565;
  void * D.30566;
  int D.30569;
  struct MonoException * exc;
  struct MonoJitInfo * ji;
  void * ctx;

  exc = 0B;
  ctx = context;
  D.30565 = mono_domain_get ();
  D.30566 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.30565, D.30566);
  exc = mono_get_exception_divide_by_zero ();
  if (ji == 0B) goto <D.30567>; else goto <D.30568>;
  <D.30567>:
  D.30569 = mono_chain_signal (_dummy, info, context);
  if (D.30569 != 0) goto <D.30570>; else goto <D.30571>;
  <D.30570>:
  return;
  <D.30571>:
  mono_handle_native_sigsegv (11, ctx);
  <D.30568>:
  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.190;
  int D.30574;
  int D.30577;
  void * D.30580;
  int D.30581;
  struct MonoDomain * D.30586;
  int D.30588;
  struct MonoDomain * D.30591;
  void * D.30592;
  int D.30595;
  struct MonoJitInfo * ji;
  struct MonoJitTlsData * jit_tls;
  void * fault_addr;
  void * ctx;

  mono_jit_tls_id.190 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.190);
  fault_addr = 0B;
  ctx = context;
  D.30574 = mono_arch_is_single_step_event (info, ctx);
  if (D.30574 != 0) goto <D.30575>; else goto <D.30576>;
  <D.30575>:
  mono_debugger_agent_single_step_event (ctx);
  return;
  <D.30576>:
  D.30577 = mono_arch_is_breakpoint_event (info, ctx);
  if (D.30577 != 0) goto <D.30578>; else goto <D.30579>;
  <D.30578>:
  mono_debugger_agent_breakpoint_hit (ctx);
  return;
  <D.30579>:
  fault_addr = info->_sifields._sigfault.si_addr;
  D.30580 = info->_sifields._sigfault.si_addr;
  D.30581 = mono_aot_is_pagefault (D.30580);
  if (D.30581 != 0) goto <D.30582>; else goto <D.30583>;
  <D.30582>:
  D.30580 = info->_sifields._sigfault.si_addr;
  mono_aot_handle_pagefault (D.30580);
  return;
  <D.30583>:
  D.30586 = mono_domain_get ();
  if (D.30586 == 0B) goto <D.30584>; else goto <D.30587>;
  <D.30587>:
  if (jit_tls == 0B) goto <D.30584>; else goto <D.30585>;
  <D.30584>:
  D.30588 = mono_chain_signal (_dummy, info, context);
  if (D.30588 != 0) goto <D.30589>; else goto <D.30590>;
  <D.30589>:
  return;
  <D.30590>:
  mono_handle_native_sigsegv (11, ctx);
  <D.30585>:
  D.30591 = mono_domain_get ();
  D.30592 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.30591, D.30592);
  if (ji == 0B) goto <D.30593>; else goto <D.30594>;
  <D.30593>:
  D.30595 = mono_chain_signal (_dummy, info, context);
  if (D.30595 != 0) goto <D.30596>; else goto <D.30597>;
  <D.30596>:
  return;
  <D.30597>:
  mono_handle_native_sigsegv (11, ctx);
  <D.30594>:
  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.30599;
  long int D.30600;
  long int D.30601;
  void * * vtable_trampolines.191;
  int D.30608;
  int vtable_trampolines_size.192;
  _Bool D.30612;
  long int D.30613;
  long int D.30614;
  int iftmp.193;
  unsigned int new_size.194;
  unsigned int D.30625;
  unsigned int vtable_trampolines_size.195;
  unsigned int D.30629;
  _Bool D.30632;
  long int D.30633;
  long int D.30634;
  unsigned int index.196;
  unsigned int D.30638;
  void * * D.30639;
  void * D.30640;
  void * slot_index.197;
  struct MonoDomain * D.30644;
  void * D.30645;
  void * D.30646;
  int index;

  index = slot_index + 19;
  D.30599 = slot_index < -19;
  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", 6834, "slot_index >= - MONO_IMT_SIZE");
  <D.30603>:
  vtable_trampolines.191 = vtable_trampolines;
  if (vtable_trampolines.191 == 0B) goto <D.30604>; else goto <D.30607>;
  <D.30607>:
  D.30608 = slot_index + 19;
  vtable_trampolines_size.192 = vtable_trampolines_size;
  if (D.30608 >= vtable_trampolines_size.192) goto <D.30604>; else goto <D.30605>;
  <D.30604>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30610>; else goto <D.30611>;
    <D.30610>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30611>:
    D.30612 = ret != 0;
    D.30613 = (long int) D.30612;
    D.30614 = __builtin_expect (D.30613, 0);
    if (D.30614 != 0) goto <D.30615>; else goto <D.30616>;
    <D.30615>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6836, "ret == 0");
    <D.30616>:
  }
  vtable_trampolines.191 = vtable_trampolines;
  if (vtable_trampolines.191 == 0B) goto <D.30617>; else goto <D.30619>;
  <D.30619>:
  vtable_trampolines_size.192 = vtable_trampolines_size;
  if (index >= vtable_trampolines_size.192) goto <D.30617>; else goto <D.30618>;
  <D.30617>:
  {
    int new_size;
    void * new_table;

    vtable_trampolines_size.192 = vtable_trampolines_size;
    if (vtable_trampolines_size.192 != 0) goto <D.30621>; else goto <D.30622>;
    <D.30621>:
    vtable_trampolines_size.192 = vtable_trampolines_size;
    iftmp.193 = vtable_trampolines_size.192 * 2;
    goto <D.30623>;
    <D.30622>:
    iftmp.193 = 128;
    <D.30623>:
    new_size = iftmp.193;
    goto <D.25921>;
    <D.25920>:
    new_size = new_size * 2;
    <D.25921>:
    if (new_size <= index) goto <D.25920>; else goto <D.25922>;
    <D.25922>:
    new_size.194 = (unsigned int) new_size;
    D.30625 = new_size.194 * 4;
    new_table = monoeg_malloc0 (D.30625);
    vtable_trampolines.191 = vtable_trampolines;
    if (vtable_trampolines.191 != 0B) goto <D.30626>; else goto <D.30627>;
    <D.30626>:
    vtable_trampolines.191 = vtable_trampolines;
    vtable_trampolines_size.192 = vtable_trampolines_size;
    vtable_trampolines_size.195 = (unsigned int) vtable_trampolines_size.192;
    D.30629 = vtable_trampolines_size.195 * 4;
    memcpy (new_table, vtable_trampolines.191, D.30629);
    <D.30627>:
    vtable_trampolines.191 = vtable_trampolines;
    monoeg_g_free (vtable_trampolines.191);
    mono_memory_barrier ();
    vtable_trampolines = new_table;
    vtable_trampolines_size = new_size;
  }
  <D.30618>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30630>; else goto <D.30631>;
    <D.30630>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30631>:
    D.30632 = ret != 0;
    D.30633 = (long int) D.30632;
    D.30634 = __builtin_expect (D.30633, 0);
    if (D.30634 != 0) goto <D.30635>; else goto <D.30636>;
    <D.30635>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6853, "ret == 0");
    <D.30636>:
  }
  <D.30605>:
  vtable_trampolines.191 = vtable_trampolines;
  index.196 = (unsigned int) index;
  D.30638 = index.196 * 4;
  D.30639 = vtable_trampolines.191 + D.30638;
  D.30640 = *D.30639;
  if (D.30640 == 0B) goto <D.30641>; else goto <D.30642>;
  <D.30641>:
  vtable_trampolines.191 = vtable_trampolines;
  index.196 = (unsigned int) index;
  D.30638 = index.196 * 4;
  D.30639 = vtable_trampolines.191 + D.30638;
  slot_index.197 = (void *) slot_index;
  D.30644 = mono_get_root_domain ();
  D.30645 = mono_create_specific_trampoline (slot_index.197, 12, D.30644, 0B);
  *D.30639 = D.30645;
  <D.30642>:
  vtable_trampolines.191 = vtable_trampolines;
  index.196 = (unsigned int) index;
  D.30638 = index.196 * 4;
  D.30639 = vtable_trampolines.191 + D.30638;
  D.30646 = *D.30639;
  return D.30646;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mini_get_debug_options ()
{
  struct MonoDebugOptions * D.30648;

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


mini_init (const char * filename, const char * runtime_version)
{
  int D.30650;
  int default_opt_set.198;
  int D.30656;
  unsigned int default_opt.199;
  struct MonoCodeManager * global_codeman.200;
  struct MonoCodeManager * global_codeman.201;
  struct GHashTable * jit_icall_name_hash.202;
  int mono_use_imt.203;
  const gchar * D.30666;
  const gchar * D.30669;
  struct MonoDebugOptions * D.30673;
  int D.30674;
  unsigned int default_opt.204;
  unsigned int D.30682;
  int D.30685;
  int mono_aot_only.205;
  struct MonoCodeManager * D.30694;
  void * D.30700;
  void * D.30701;
  void * D.30702;
  int mono_compile_aot.206;
  struct MonoDomain * D.30706;
  struct MonoDomain * domain;
  struct MonoRuntimeCallbacks callbacks;
  struct MonoThreadInfoRuntimeCallbacks ticallbacks;

  try
    {
      D.30650 = access ("/proc/self/maps", 0);
      if (D.30650 != 0) goto <D.30651>; else goto <D.30652>;
      <D.30651>:
      monoeg_g_print ("Mono requires /proc to be mounted.\n");
      exit (1);
      <D.30652>:
      InitializeCriticalSection (&jit_mutex);
      default_opt_set.198 = default_opt_set;
      if (default_opt_set.198 == 0) goto <D.30654>; else goto <D.30655>;
      <D.30654>:
      D.30656 = mono_parse_default_optimizations (0B);
      default_opt.199 = (unsigned int) D.30656;
      default_opt = default_opt.199;
      <D.30655>:
      mono_runtime_set_has_tls_get (0);
      global_codeman.200 = global_codeman;
      if (global_codeman.200 == 0B) goto <D.30659>; else goto <D.30660>;
      <D.30659>:
      global_codeman.201 = mono_code_manager_new ();
      global_codeman = global_codeman.201;
      <D.30660>:
      jit_icall_name_hash.202 = 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.202;
      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.203 = mono_use_imt;
      if (mono_use_imt.203 != 0) goto <D.30664>; else goto <D.30665>;
      <D.30664>:
      callbacks.get_vtable_trampoline = mini_get_vtable_trampoline;
      callbacks.get_imt_trampoline = mini_get_imt_trampoline;
      <D.30665>:
      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.30666 = monoeg_g_getenv ("MONO_DEBUG");
      if (D.30666 != 0B) goto <D.30667>; else goto <D.30668>;
      <D.30667>:
      mini_parse_debug_options ();
      <D.30668>:
      mono_code_manager_init ();
      mono_hwcap_init ();
      mono_arch_cpu_init ();
      mono_arch_init ();
      mono_unwind_init ();
      D.30669 = monoeg_g_getenv ("MONO_XDEBUG");
      if (D.30669 != 0B) goto <D.30670>; else goto <D.30671>;
      <D.30670>:
      {
        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.30672>;
      <D.30671>:
      D.30673 = mini_get_debug_options ();
      D.30674 = D.30673->gdb;
      if (D.30674 != 0) goto <D.30675>; else goto <D.30676>;
      <D.30675>:
      mono_xdebug_init ("gdb");
      mono_dont_free_domains = 1;
      mono_using_xdebug = 1;
      <D.30676>:
      <D.30672>:
      mono_trampolines_init ();
      if (0 != 0) goto <D.30677>; else goto <D.30678>;
      <D.30677>:
      if (0 != 0) goto <D.30679>; else goto <D.30680>;
      <D.30679>:
      monoeg_g_log (0B, 4, "No vtable supported in g_thread_init");
      <D.26145>:
      goto <D.26145>;
      <D.30680>:
      <D.30678>:
      mono_native_tls_alloc (&mono_jit_tls_id, 0B);
      default_opt.204 = default_opt;
      D.30682 = default_opt.204 & 65536;
      if (D.30682 != 0) goto <D.30683>; else goto <D.30684>;
      <D.30683>:
      mono_aot_init ();
      <D.30684>:
      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.30685 = debug_options.collect_pagefault_stats;
      if (D.30685 != 0) goto <D.30686>; else goto <D.30687>;
      <D.30686>:
      mono_aot_set_make_unreadable (1);
      <D.30687>:
      if (runtime_version != 0B) goto <D.30688>; else goto <D.30689>;
      <D.30688>:
      domain = mono_init_version (filename, runtime_version);
      goto <D.30690>;
      <D.30689>:
      domain = mono_init_from_assembly (filename, filename);
      <D.30690>:
      mono_aot_only.205 = mono_aot_only;
      if (mono_aot_only.205 != 0) goto <D.30692>; else goto <D.30693>;
      <D.30692>:
      D.30694 = domain->code_mp;
      mono_code_manager_set_read_only (D.30694);
      mono_marshal_use_aot_wrappers (1);
      <D.30693>:
      mono_use_imt.203 = mono_use_imt;
      if (mono_use_imt.203 != 0) goto <D.30695>; else goto <D.30696>;
      <D.30695>:
      mono_aot_only.205 = mono_aot_only;
      if (mono_aot_only.205 != 0) goto <D.30697>; else goto <D.30698>;
      <D.30697>:
      mono_install_imt_thunk_builder (mono_aot_get_imt_thunk);
      goto <D.30699>;
      <D.30698>:
      mono_install_imt_thunk_builder (mono_arch_build_imt_thunk);
      <D.30699>:
      <D.30696>:
      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.30700 = mono_get_throw_exception ();
      register_dyn_icall (D.30700, "mono_arch_throw_exception", "void object", 1);
      D.30701 = mono_get_rethrow_exception ();
      register_dyn_icall (D.30701, "mono_arch_rethrow_exception", "void object", 1);
      D.30702 = mono_get_throw_corlib_exception ();
      register_dyn_icall (D.30702, "mono_arch_throw_corlib_exception", "void ptr", 1);
      register_icall (mono_thread_get_undeniable_exception, "mono_thread_get_undeniable_exception", "object", 0);
      register_icall (mono_thread_interruption_checkpoint, "mono_thread_interruption_checkpoint", "void", 0);
      register_icall (mono_thread_force_interruption_checkpoint, "mono_thread_force_interruption_checkpoint", "void", 0);
      register_icall (mono_load_remote_field_new, "mono_load_remote_field_new", "object object ptr ptr", 0);
      register_icall (mono_store_remote_field_new, "mono_store_remote_field_new", "void object ptr ptr object", 0);
      register_opcode_emulation (481, "__emul_lmul", "long long long", mono_llmult, "mono_llmult", 1);
      register_opcode_emulation (482, "__emul_ldiv", "long long long", mono_lldiv, "mono_lldiv", 0);
      register_opcode_emulation (483, "__emul_ldiv_un", "long long long", mono_lldiv_un, "mono_lldiv_un", 0);
      register_opcode_emulation (484, "__emul_lrem", "long long long", mono_llrem, "mono_llrem", 0);
      register_opcode_emulation (485, "__emul_lrem_un", "long long long", mono_llrem_un, "mono_llrem_un", 0);
      register_opcode_emulation (510, "__emul_lmul_ovf_un", "long long long", mono_llmult_ovf_un, "mono_llmult_ovf_un", 0);
      register_opcode_emulation (509, "__emul_lmul_ovf", "long long long", mono_llmult_ovf, "mono_llmult_ovf", 0);
      register_opcode_emulation (489, "__emul_lshl", "long long int32", mono_lshl, "mono_lshl", 1);
      register_opcode_emulation (490, "__emul_lshr", "long long int32", mono_lshr, "mono_lshr", 1);
      register_opcode_emulation (491, "__emul_lshr_un", "long long int32", mono_lshr_un, "mono_lshr_un", 1);
      register_opcode_emulation (684, "__emul_fconv_to_u8", "ulong double", mono_fconv_u8, "mono_fconv_u8", 0);
      register_opcode_emulation (683, "__emul_fconv_to_u4", "uint32 double", mono_fconv_u4, "mono_fconv_u4", 0);
      register_opcode_emulation (712, "__emul_fconv_to_ovf_i8", "long double", mono_fconv_ovf_i8, "mono_fconv_ovf_i8", 0);
      register_opcode_emulation (713, "__emul_fconv_to_ovf_u8", "ulong double", mono_fconv_ovf_u8, "mono_fconv_ovf_u8", 0);
      register_opcode_emulation (680, "__emul_fconv_to_i8", "long double", mono_fconv_i8, "mono_fconv_i8", 0);
      register_opcode_emulation (499, "__emul_lconv_to_r8", "double long", mono_lconv_to_r8, "mono_lconv_to_r8", 0);
      register_opcode_emulation (498, "__emul_lconv_to_r4", "float long", mono_lconv_to_r4, "mono_lconv_to_r4", 0);
      register_opcode_emulation (536, "__emul_lconv_to_r8_un", "double long", mono_lconv_to_r8_un, "mono_lconv_to_r8_un", 0);
      register_opcode_emulation (673, "__emul_frem", "double double double", fmod, "fmod", 0);
      register_opcode_emulation (727, "__emul_fconv_to_u", "uint32 double", mono_fconv_u4, "mono_fconv_u4", 1);
      register_icall (mono_delegate_ctor, "mono_delegate_ctor", "void object object ptr", 0);
      register_icall (mono_class_static_field_address, "mono_class_static_field_address", "ptr ptr ptr", 0);
      register_icall (mono_ldtoken_wrapper, "mono_ldtoken_wrapper", "ptr ptr ptr ptr", 0);
      register_icall (mono_ldtoken_wrapper_generic_shared, "mono_ldtoken_wrapper_generic_shared", "ptr ptr ptr ptr", 0);
      register_icall (mono_get_special_static_data, "mono_get_special_static_data", "ptr int", 0);
      register_icall (mono_ldstr, "mono_ldstr", "object ptr ptr int32", 0);
      register_icall (mono_helper_stelem_ref_check, "mono_helper_stelem_ref_check", "void object object", 0);
      register_icall (mono_object_new, "mono_object_new", "object ptr ptr", 0);
      register_icall (mono_object_new_specific, "mono_object_new_specific", "object ptr", 0);
      register_icall (mono_array_new, "mono_array_new", "object ptr ptr int32", 0);
      register_icall (mono_array_new_specific, "mono_array_new_specific", "object ptr int32", 0);
      register_icall (mono_runtime_class_init, "mono_runtime_class_init", "void ptr", 0);
      register_icall (mono_ldftn, "mono_ldftn", "ptr ptr", 0);
      register_icall (mono_ldvirtfn, "mono_ldvirtfn", "ptr object ptr", 0);
      register_icall (mono_ldvirtfn_gshared, "mono_ldvirtfn_gshared", "ptr object ptr", 0);
      register_icall (mono_helper_compile_generic_method, "mono_helper_compile_generic_method", "ptr object ptr ptr", 0);
      register_icall (mono_helper_ldstr, "mono_helper_ldstr", "object ptr int", 0);
      register_icall (mono_helper_ldstr_mscorlib, "mono_helper_ldstr_mscorlib", "object int", 0);
      register_icall (mono_helper_newobj_mscorlib, "mono_helper_newobj_mscorlib", "object int", 0);
      register_icall (mono_value_copy, "mono_value_copy", "void ptr ptr ptr", 0);
      register_icall (mono_object_castclass_unbox, "mono_object_castclass_unbox", "object object ptr", 0);
      register_icall (mono_break, "mono_break", 0B, 1);
      register_icall (mono_create_corlib_exception_0, "mono_create_corlib_exception_0", "object int", 1);
      register_icall (mono_create_corlib_exception_1, "mono_create_corlib_exception_1", "object int object", 1);
      register_icall (mono_create_corlib_exception_2, "mono_create_corlib_exception_2", "object int object object", 1);
      register_icall (mono_array_new_1, "mono_array_new_1", "object ptr int", 0);
      register_icall (mono_array_new_2, "mono_array_new_2", "object ptr int int", 0);
      register_icall (mono_array_new_3, "mono_array_new_3", "object ptr int int int", 0);
      register_icall (mono_array_new_4, "mono_array_new_4", "object ptr int int int int", 0);
      register_icall (mono_get_native_calli_wrapper, "mono_get_native_calli_wrapper", "ptr ptr ptr ptr", 0);
      register_icall (mono_resume_unwind, "mono_resume_unwind", "void", 1);
      register_icall (mono_gsharedvt_constrained_call, "mono_gsharedvt_constrained_call", "object ptr ptr ptr ptr ptr", 0);
      register_icall (mono_gsharedvt_value_copy, "mono_gsharedvt_value_copy", "void ptr ptr ptr", 1);
      register_icall (mono_gc_wbarrier_value_copy_bitmap, "mono_gc_wbarrier_value_copy_bitmap", "void ptr ptr int int", 0);
      register_icall (mono_object_castclass_with_cache, "mono_object_castclass_with_cache", "object object ptr ptr", 0);
      register_icall (mono_object_isinst_with_cache, "mono_object_isinst_with_cache", "object object ptr ptr", 0);
      register_icall (mono_debugger_agent_user_break, "mono_debugger_agent_user_break", "void", 0);
      mono_generic_sharing_init ();
      mono_compile_aot.206 = mono_compile_aot;
      if (mono_compile_aot.206 != 0) goto <D.30704>; else goto <D.30705>;
      <D.30704>:
      mono_runtime_set_no_exec (1);
      <D.30705>:
      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.30706 = domain;
      return D.30706;
    }
  finally
    {
      callbacks = {CLOBBER};
      ticallbacks = {CLOBBER};
    }
}


mono_thread_attach_cb (intptr_t tid, void * stack_start)
{
  <unnamed type> D.30711;
  unsigned int D.30712;
  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.30709>; else goto <D.30710>;
  <D.30709>:
  thread->jit_data = jit_tls;
  <D.30710>:
  D.30711 = mono_profiler_get_events ();
  D.30712 = D.30711 & 32768;
  if (D.30712 != 0) goto <D.30713>; else goto <D.30714>;
  <D.30713>:
  mono_runtime_setup_stat_profiler ();
  <D.30714>:
  mono_arch_cpu_init ();
}


mono_thread_abort_dummy (struct MonoObject * obj)
{
  void (*<T3530>) (struct MonoObject *) mono_thread_attach_aborted_cb.207;

  mono_thread_attach_aborted_cb.207 = mono_thread_attach_aborted_cb;
  if (mono_thread_attach_aborted_cb.207 != 0B) goto <D.30716>; else goto <D.30717>;
  <D.30716>:
  mono_thread_attach_aborted_cb.207 = mono_thread_attach_aborted_cb;
  mono_thread_attach_aborted_cb.207 (obj);
  goto <D.30718>;
  <D.30717>:
  mono_thread_abort (obj);
  <D.30718>:
}


mono_thread_abort (struct MonoObject * obj)
{
  <unnamed type> D.30722;
  struct MonoVTable * D.30724;
  struct MonoClass * D.30725;
  struct MonoClass * D.30726;

  D.30722 = mono_runtime_unhandled_exception_policy_get ();
  if (D.30722 == 0) goto <D.30719>; else goto <D.30723>;
  <D.30723>:
  D.30724 = obj->vtable;
  D.30725 = D.30724->klass;
  D.30726 = mono_defaults.threadabortexception_class;
  if (D.30725 == D.30726) goto <D.30719>; else goto <D.30720>;
  <D.30719>:
  mono_thread_exit ();
  goto <D.30721>;
  <D.30720>:
  mono_invoke_unhandled_exception_hook (obj);
  <D.30721>:
}


setup_jit_tls_data (void * stack_start, void * abort_func)
{
  unsigned int mono_jit_tls_id.208;
  void * D.30730;
  void (*<T3530>) (struct MonoObject *) abort_func.209;
  struct MonoLMF * * D.30732;
  struct MonoJitTlsData * jit_tls;
  struct MonoLMF * lmf;

  mono_jit_tls_id.208 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.208);
  if (jit_tls != 0B) goto <D.30728>; else goto <D.30729>;
  <D.30728>:
  D.30730 = jit_tls;
  return D.30730;
  <D.30729>:
  jit_tls = monoeg_malloc0 (1392);
  abort_func.209 = (void (*<T3530>) (struct MonoObject *)) abort_func;
  jit_tls->abort_func = abort_func.209;
  jit_tls->end_of_stack = stack_start;
  mono_set_jit_tls (jit_tls);
  lmf = monoeg_malloc0 (276);
  jit_tls->first_lmf = lmf;
  D.30732 = &jit_tls->lmf;
  mono_set_lmf_addr (D.30732);
  jit_tls->lmf = lmf;
  mono_setup_altstack (jit_tls);
  D.30730 = jit_tls;
  return D.30730;
}


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

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


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.30735;
  int D.30736;
  _Bool D.30737;

  D.30736 = pthread_setspecific (key, value);
  D.30737 = D.30736 == 0;
  D.30735 = (int) D.30737;
  return D.30735;
}


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


mono_jit_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  short unsigned int D.30743;
  int D.30744;
  int D.30745;
  unsigned int D.30748;
  unsigned int D.30749;
  struct MonoObject * D.30752;
  union mono_mutex_t * D.30753;
  _Bool D.30756;
  long int D.30757;
  long int D.30758;
  struct GHashTable * D.30761;
  _Bool D.30764;
  long int D.30765;
  long int D.30766;
  <unnamed type> D.30771;
  struct MonoClass * D.30774;
  unsigned char D.30775;
  struct MonoException * D.30780;
  struct MonoException * D.30782;
  struct MonoVTable * D.30783;
  struct MonoVTable * D.30784;
  _Bool D.30785;
  long int D.30786;
  long int D.30787;
  unsigned char D.30790;
  short unsigned int D.30793;
  unsigned int D.30794;
  unsigned int D.30795;
  int mono_aot_only.211;
  unsigned int default_opt.212;
  unsigned int D.30805;
  void * D.30806;
  void * D.30807;
  struct MonoException * jit_ex.213;
  _Bool D.30811;
  long int D.30812;
  long int D.30813;
  int D.30818;
  void * D.30819;
  struct MonoDynCallInfo * D.30821;
  void * D.30824;
  _Bool D.30827;
  long int D.30828;
  long int D.30829;
  _Bool D.30837;
  long int D.30838;
  long int D.30839;
  void * D.30842;
  struct MonoException * D.30845;
  struct MonoObject * D.30846;
  struct MonoMethod * invoke;
  struct MonoMethod * callee;
  struct MonoObject * (*<T319d>) (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.30741>; else goto <D.30742>;
  <D.30741>:
  D.30743 = method->flags;
  D.30744 = (int) D.30743;
  D.30745 = D.30744 & 16;
  if (D.30745 == 0) goto <D.30746>; else goto <D.30747>;
  <D.30746>:
  D.30748 = BIT_FIELD_REF <*method, 32, 160>;
  D.30749 = D.30748 & 252;
  if (D.30749 == 0) goto <D.30750>; else goto <D.30751>;
  <D.30750>:
  monoeg_g_log (0B, 16, "Ignoring invocation of an instance method on a NULL instance.\n");
  D.30752 = 0B;
  return D.30752;
  <D.30751>:
  <D.30747>:
  <D.30742>:
  domain_info = domain->runtime_info;
  {
    int ret;

    D.30753 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.30753);
    if (ret != 0) goto <D.30754>; else goto <D.30755>;
    <D.30754>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30755>:
    D.30756 = ret != 0;
    D.30757 = (long int) D.30756;
    D.30758 = __builtin_expect (D.30757, 0);
    if (D.30758 != 0) goto <D.30759>; else goto <D.30760>;
    <D.30759>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6436, "ret == 0");
    <D.30760>:
  }
  D.30761 = domain_info->runtime_invoke_hash;
  info = monoeg_g_hash_table_lookup (D.30761, method);
  {
    int ret;

    D.30753 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30753);
    if (ret != 0) goto <D.30762>; else goto <D.30763>;
    <D.30762>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30763>:
    D.30764 = ret != 0;
    D.30765 = (long int) D.30764;
    D.30766 = __builtin_expect (D.30765, 0);
    if (D.30766 != 0) goto <D.30767>; else goto <D.30768>;
    <D.30767>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6438, "ret == 0");
    <D.30768>:
  }
  if (info == 0B) goto <D.30769>; else goto <D.30770>;
  <D.30769>:
  D.30771 = mono_security_get_mode ();
  if (D.30771 == 1) goto <D.30772>; else goto <D.30773>;
  <D.30772>:
  D.30774 = method->klass;
  mono_class_setup_vtable (D.30774);
  D.30774 = method->klass;
  D.30775 = D.30774->exception_type;
  if (D.30775 != 0) goto <D.30776>; else goto <D.30777>;
  <D.30776>:
  if (exc != 0B) goto <D.30778>; else goto <D.30779>;
  <D.30778>:
  D.30774 = method->klass;
  D.30780 = mono_class_get_exception_for_failure (D.30774);
  *exc = D.30780;
  goto <D.30781>;
  <D.30779>:
  D.30774 = method->klass;
  D.30782 = mono_class_get_exception_for_failure (D.30774);
  mono_raise_exception (D.30782);
  <D.30781>:
  D.30752 = 0B;
  return D.30752;
  <D.30777>:
  <D.30773>:
  info = monoeg_malloc0 (24);
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  D.30774 = method->klass;
  D.30783 = mono_class_vtable_full (domain, D.30774, 1);
  info->vtable = D.30783;
  D.30784 = info->vtable;
  D.30785 = D.30784 == 0B;
  D.30786 = (long int) D.30785;
  D.30787 = __builtin_expect (D.30786, 0);
  if (D.30787 != 0) goto <D.30788>; else goto <D.30789>;
  <D.30788>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6460, "info->vtable");
  <D.30789>:
  callee = method;
  D.30774 = method->klass;
  D.30790 = D.30774->rank;
  if (D.30790 != 0) goto <D.30791>; else goto <D.30792>;
  <D.30791>:
  D.30793 = method->iflags;
  D.30794 = (unsigned int) D.30793;
  D.30795 = D.30794 & 4097;
  if (D.30795 == 4097) goto <D.30796>; else goto <D.30797>;
  <D.30796>:
  mono_aot_only.211 = mono_aot_only;
  if (mono_aot_only.211 != 0) goto <D.30799>; else goto <D.30800>;
  <D.30799>:
  {
    struct MonoMethod * wrapper;

    wrapper = mono_marshal_get_array_accessor_wrapper (method);
    invoke = mono_marshal_get_runtime_invoke (wrapper, 0);
    callee = wrapper;
  }
  goto <D.30801>;
  <D.30800>:
  callee = 0B;
  <D.30801>:
  <D.30797>:
  <D.30792>:
  if (callee != 0B) goto <D.30802>; else goto <D.30803>;
  <D.30802>:
  {
    struct MonoException * jit_ex;

    try
      {
        jit_ex = 0B;
        default_opt.212 = default_opt;
        D.30805 = mono_get_optimizations_for_method (callee, default_opt.212);
        D.30806 = mono_jit_compile_method_with_opt (callee, D.30805, &jit_ex);
        info->compiled_method = D.30806;
        D.30807 = info->compiled_method;
        if (D.30807 == 0B) goto <D.30808>; else goto <D.30809>;
        <D.30808>:
        monoeg_g_free (info);
        jit_ex.213 = jit_ex;
        D.30811 = jit_ex.213 == 0B;
        D.30812 = (long int) D.30811;
        D.30813 = __builtin_expect (D.30812, 0);
        if (D.30813 != 0) goto <D.30814>; else goto <D.30815>;
        <D.30814>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6489, "jit_ex");
        <D.30815>:
        if (exc != 0B) goto <D.30816>; else goto <D.30817>;
        <D.30816>:
        jit_ex.213 = jit_ex;
        *exc = jit_ex.213;
        D.30752 = 0B;
        return D.30752;
        <D.30817>:
        jit_ex.213 = jit_ex;
        mono_raise_exception (jit_ex.213);
        <D.30809>:
        D.30807 = info->compiled_method;
        D.30818 = mono_method_needs_static_rgctx_invoke (callee, 0);
        D.30819 = mini_add_method_trampoline (0B, callee, D.30807, D.30818, 0);
        info->compiled_method = D.30819;
      }
    finally
      {
        jit_ex = {CLOBBER};
      }
  }
  goto <D.30820>;
  <D.30803>:
  info->compiled_method = 0B;
  <D.30820>:
  D.30821 = info->dyn_call_info;
  if (D.30821 == 0B) goto <D.30822>; else goto <D.30823>;
  <D.30822>:
  D.30824 = mono_jit_compile_method (invoke);
  info->runtime_invoke = D.30824;
  <D.30823>:
  {
    int ret;

    D.30753 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.30753);
    if (ret != 0) goto <D.30825>; else goto <D.30826>;
    <D.30825>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30826>:
    D.30827 = ret != 0;
    D.30828 = (long int) D.30827;
    D.30829 = __builtin_expect (D.30828, 0);
    if (D.30829 != 0) goto <D.30830>; else goto <D.30831>;
    <D.30830>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6579, "ret == 0");
    <D.30831>:
  }
  D.30761 = domain_info->runtime_invoke_hash;
  info2 = monoeg_g_hash_table_lookup (D.30761, method);
  if (info2 != 0B) goto <D.30832>; else goto <D.30833>;
  <D.30832>:
  monoeg_g_free (info);
  info = info2;
  goto <D.30834>;
  <D.30833>:
  D.30761 = domain_info->runtime_invoke_hash;
  monoeg_g_hash_table_insert_replace (D.30761, method, info, 0);
  <D.30834>:
  {
    int ret;

    D.30753 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30753);
    if (ret != 0) goto <D.30835>; else goto <D.30836>;
    <D.30835>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30836>:
    D.30837 = ret != 0;
    D.30838 = (long int) D.30837;
    D.30839 = __builtin_expect (D.30838, 0);
    if (D.30839 != 0) goto <D.30840>; else goto <D.30841>;
    <D.30840>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6587, "ret == 0");
    <D.30841>:
  }
  <D.30770>:
  D.30842 = info->runtime_invoke;
  runtime_invoke = (struct MonoObject * (*<T319d>) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.30842;
  if (exc != 0B) goto <D.30843>; else goto <D.30844>;
  <D.30843>:
  D.30784 = info->vtable;
  D.30845 = mono_runtime_class_init_full (D.30784, 0);
  *exc = D.30845;
  D.30846 = *exc;
  if (D.30846 != 0B) goto <D.30847>; else goto <D.30848>;
  <D.30847>:
  D.30752 = 0B;
  return D.30752;
  <D.30848>:
  goto <D.30849>;
  <D.30844>:
  D.30784 = info->vtable;
  mono_runtime_class_init (D.30784);
  <D.30849>:
  if (exc != 0B) goto <D.30850>; else goto <D.30851>;
  <D.30850>:
  *exc = 0B;
  <D.30851>:
  D.30807 = info->compiled_method;
  D.30752 = runtime_invoke (obj, params, exc, D.30807);
  return D.30752;
}


mini_free_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.30855;
  struct GHashTable * D.30856;
  struct GHashTable * D.30859;
  struct GHashTable * D.30862;
  struct GHashTable * D.30865;
  struct GHashTable * D.30866;
  struct GHashTable * D.30867;
  struct GHashTable * D.30868;
  struct GHashTable * D.30869;
  struct GHashTable * D.30872;
  struct GHashTable * D.30873;
  struct GHashTable * D.30874;
  struct GHashTable * D.30875;
  void * D.30876;
  struct GHashTable * D.30879;
  void * D.30882;
  struct MonoJitDomainInfo * info;

  info = domain->runtime_info;
  D.30855 = info->jump_target_hash;
  monoeg_g_hash_table_foreach (D.30855, delete_jump_list, 0B);
  D.30855 = info->jump_target_hash;
  monoeg_g_hash_table_destroy (D.30855);
  D.30856 = info->jump_target_got_slot_hash;
  if (D.30856 != 0B) goto <D.30857>; else goto <D.30858>;
  <D.30857>:
  D.30856 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_foreach (D.30856, delete_got_slot_list, 0B);
  D.30856 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_destroy (D.30856);
  <D.30858>:
  D.30859 = info->dynamic_code_hash;
  if (D.30859 != 0B) goto <D.30860>; else goto <D.30861>;
  <D.30860>:
  D.30859 = info->dynamic_code_hash;
  monoeg_g_hash_table_foreach (D.30859, dynamic_method_info_free, 0B);
  D.30859 = info->dynamic_code_hash;
  monoeg_g_hash_table_destroy (D.30859);
  <D.30861>:
  D.30862 = info->method_code_hash;
  if (D.30862 != 0B) goto <D.30863>; else goto <D.30864>;
  <D.30863>:
  D.30862 = info->method_code_hash;
  monoeg_g_hash_table_destroy (D.30862);
  <D.30864>:
  D.30865 = info->class_init_trampoline_hash;
  monoeg_g_hash_table_destroy (D.30865);
  D.30866 = info->jump_trampoline_hash;
  monoeg_g_hash_table_destroy (D.30866);
  D.30867 = info->jit_trampoline_hash;
  monoeg_g_hash_table_destroy (D.30867);
  D.30868 = info->delegate_trampoline_hash;
  monoeg_g_hash_table_destroy (D.30868);
  D.30869 = info->static_rgctx_trampoline_hash;
  if (D.30869 != 0B) goto <D.30870>; else goto <D.30871>;
  <D.30870>:
  D.30869 = info->static_rgctx_trampoline_hash;
  monoeg_g_hash_table_destroy (D.30869);
  <D.30871>:
  D.30872 = info->llvm_vcall_trampoline_hash;
  monoeg_g_hash_table_destroy (D.30872);
  D.30873 = info->runtime_invoke_hash;
  monoeg_g_hash_table_destroy (D.30873);
  D.30874 = info->seq_points;
  monoeg_g_hash_table_destroy (D.30874);
  D.30875 = info->arch_seq_points;
  monoeg_g_hash_table_destroy (D.30875);
  D.30876 = info->agent_info;
  if (D.30876 != 0B) goto <D.30877>; else goto <D.30878>;
  <D.30877>:
  mono_debugger_agent_free_domain_info (domain);
  <D.30878>:
  D.30879 = info->gsharedvt_arg_tramp_hash;
  if (D.30879 != 0B) goto <D.30880>; else goto <D.30881>;
  <D.30880>:
  D.30879 = info->gsharedvt_arg_tramp_hash;
  monoeg_g_hash_table_destroy (D.30879);
  <D.30881>:
  D.30882 = domain->runtime_info;
  monoeg_g_free (D.30882);
  domain->runtime_info = 0B;
}


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

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

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


mini_create_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.30885;
  struct GHashTable * D.30886;
  struct GHashTable * D.30887;
  struct GHashTable * D.30888;
  struct GHashTable * D.30889;
  struct GHashTable * D.30890;
  struct GHashTable * D.30891;
  struct GHashTable * D.30892;
  struct GHashTable * D.30893;
  struct MonoJitDomainInfo * info;

  info = monoeg_malloc0 (196);
  D.30885 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->class_init_trampoline_hash = D.30885;
  D.30886 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jump_trampoline_hash = D.30886;
  D.30887 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jit_trampoline_hash = D.30887;
  D.30888 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->delegate_trampoline_hash = D.30888;
  D.30889 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->llvm_vcall_trampoline_hash = D.30889;
  D.30890 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, runtime_invoke_info_free);
  info->runtime_invoke_hash = D.30890;
  D.30891 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, seq_point_info_free);
  info->seq_points = D.30891;
  D.30892 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->arch_seq_points = D.30892;
  D.30893 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_hash = D.30893;
  domain->runtime_info = info;
}


seq_point_info_free (void * value)
{
  int * D.30894;
  int D.30895;
  int i;
  struct MonoSeqPointInfo * info;

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

    sp = &info->seq_points[i];
    D.30894 = sp->next;
    monoeg_g_free (D.30894);
  }
  i = i + 1;
  <D.26131>:
  D.30895 = info->len;
  if (D.30895 > i) goto <D.26130>; else goto <D.26132>;
  <D.26132>:
  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.30896;
  int D.30897;
  int D.30898;
  struct MonoMethodSignature * D.30901;
  short unsigned int D.30902;
  void * D.30905;
  int D.30909;
  struct MonoMethodSignature * D.30911;
  unsigned int D.30912;
  unsigned int D.30913;
  struct MonoClass * D.30915;
  unsigned int D.30916;
  unsigned int D.30917;
  struct MonoClass * D.30919;
  struct MonoMethod * nm;
  guint8 * addr;

  addr = 0B;
  D.30896 = method->flags;
  D.30897 = (int) D.30896;
  D.30898 = D.30897 & 64;
  if (D.30898 != 0) goto <D.30899>; else goto <D.30900>;
  <D.30899>:
  D.30901 = mono_method_signature (method);
  D.30902 = D.30901->generic_param_count;
  if (D.30902 != 0) goto <D.30903>; else goto <D.30904>;
  <D.30903>:
  D.30905 = mono_create_specific_trampoline (method, 9, domain, 0B);
  return D.30905;
  <D.30904>:
  <D.30900>:
  D.30896 = method->flags;
  D.30897 = (int) D.30896;
  D.30909 = D.30897 & 1024;
  if (D.30909 != 0) goto <D.30906>; else goto <D.30910>;
  <D.30910>:
  D.30911 = mono_method_signature (method);
  D.30912 = BIT_FIELD_REF <*D.30911, 32, 64>;
  D.30913 = D.30912 & 4194304;
  if (D.30913 != 0) goto <D.30914>; else goto <D.30907>;
  <D.30914>:
  D.30915 = method->klass;
  D.30916 = BIT_FIELD_REF <*D.30915, 32, 160>;
  D.30917 = D.30916 & 4194304;
  if (D.30917 != 0) goto <D.30906>; else goto <D.30918>;
  <D.30918>:
  D.30915 = method->klass;
  D.30919 = mono_defaults.object_class;
  if (D.30915 == D.30919) goto <D.30906>; else goto <D.30907>;
  <D.30906>:
  nm = mono_marshal_get_remoting_invoke_for_target (method, target);
  addr = mono_compile_method (nm);
  goto <D.30908>;
  <D.30907>:
  addr = mono_compile_method (method);
  <D.30908>:
  D.30905 = mono_get_addr_from_ftnptr (addr);
  return D.30905;
}


mono_jit_free_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  unsigned int D.30921;
  unsigned int D.30922;
  _Bool D.30923;
  long int D.30924;
  long int D.30925;
  union mono_mutex_t * D.30928;
  _Bool D.30931;
  long int D.30932;
  long int D.30933;
  _Bool D.30938;
  long int D.30939;
  long int D.30940;
  _Bool D.30947;
  long int D.30948;
  long int D.30949;
  void * D.30952;
  struct GHashTable * D.30953;
  struct MonoInternalHashTable * D.30954;
  struct GHashTable * D.30955;
  struct GHashTable * D.30956;
  struct GHashTable * D.30957;
  struct MonoJumpList * jlist.214;
  struct MonoJitInfo * D.30959;
  void * D.30960;
  int D.30963;
  sizetype D.30964;
  guint8 * D.30965;
  struct GSList * D.30968;
  void * D.30969;
  struct GSList * D.30970;
  int D.30971;
  _Bool D.30974;
  long int D.30975;
  long int D.30976;
  struct MonoCodeManager * D.30981;
  struct MonoJitDynamicMethodInfo * ji;
  gboolean destroy;
  struct GHashTableIter iter;
  struct MonoJumpList * jlist;

  try
    {
      destroy = 1;
      D.30921 = BIT_FIELD_REF <*method, 32, 160>;
      D.30922 = D.30921 & 512;
      D.30923 = D.30922 == 0;
      D.30924 = (long int) D.30923;
      D.30925 = __builtin_expect (D.30924, 0);
      if (D.30925 != 0) goto <D.30926>; else goto <D.30927>;
      <D.30926>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6280, "method->dynamic");
      <D.30927>:
      {
        int ret;

        D.30928 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.30928);
        if (ret != 0) goto <D.30929>; else goto <D.30930>;
        <D.30929>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30930>:
        D.30931 = ret != 0;
        D.30932 = (long int) D.30931;
        D.30933 = __builtin_expect (D.30932, 0);
        if (D.30933 != 0) goto <D.30934>; else goto <D.30935>;
        <D.30934>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6282, "ret == 0");
        <D.30935>:
      }
      ji = mono_dynamic_code_hash_lookup (domain, method);
      {
        int ret;

        D.30928 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.30928);
        if (ret != 0) goto <D.30936>; else goto <D.30937>;
        <D.30936>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30937>:
        D.30938 = ret != 0;
        D.30939 = (long int) D.30938;
        D.30940 = __builtin_expect (D.30939, 0);
        if (D.30940 != 0) goto <D.30941>; else goto <D.30942>;
        <D.30941>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6284, "ret == 0");
        <D.30942>:
      }
      if (ji == 0B) goto <D.30943>; else goto <D.30944>;
      <D.30943>:
      return;
      <D.30944>:
      mono_debug_remove_method (method, domain);
      {
        int ret;

        D.30928 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.30928);
        if (ret != 0) goto <D.30945>; else goto <D.30946>;
        <D.30945>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30946>:
        D.30947 = ret != 0;
        D.30948 = (long int) D.30947;
        D.30949 = __builtin_expect (D.30948, 0);
        if (D.30949 != 0) goto <D.30950>; else goto <D.30951>;
        <D.30950>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6291, "ret == 0");
        <D.30951>:
      }
      D.30952 = domain->runtime_info;
      D.30953 = MEM[(struct MonoJitDomainInfo *)D.30952].dynamic_code_hash;
      monoeg_g_hash_table_remove (D.30953, method);
      D.30954 = &domain->jit_code_hash;
      mono_internal_hash_table_remove (D.30954, method);
      D.30952 = domain->runtime_info;
      D.30955 = MEM[(struct MonoJitDomainInfo *)D.30952].jump_trampoline_hash;
      monoeg_g_hash_table_remove (D.30955, method);
      D.30952 = domain->runtime_info;
      D.30956 = MEM[(struct MonoJitDomainInfo *)D.30952].runtime_invoke_hash;
      monoeg_g_hash_table_remove (D.30956, method);
      D.30952 = domain->runtime_info;
      D.30957 = MEM[(struct MonoJitDomainInfo *)D.30952].jump_target_hash;
      monoeg_g_hash_table_iter_init (&iter, D.30957);
      goto <D.25819>;
      <D.25818>:
      {
        struct GSList * tmp;
        struct GSList * remove;

        remove = 0B;
        jlist.214 = jlist;
        tmp = jlist.214->list;
        goto <D.25813>;
        <D.25812>:
        {
          guint8 * ip;

          ip = tmp->data;
          D.30959 = ji->ji;
          D.30960 = D.30959->code_start;
          if (D.30960 <= ip) goto <D.30961>; else goto <D.30962>;
          <D.30961>:
          D.30959 = ji->ji;
          D.30960 = D.30959->code_start;
          D.30959 = ji->ji;
          D.30963 = D.30959->code_size;
          D.30964 = (sizetype) D.30963;
          D.30965 = D.30960 + D.30964;
          if (D.30965 > ip) goto <D.30966>; else goto <D.30967>;
          <D.30966>:
          remove = monoeg_g_slist_prepend (remove, tmp);
          <D.30967>:
          <D.30962>:
        }
        tmp = tmp->next;
        <D.25813>:
        if (tmp != 0B) goto <D.25812>; else goto <D.25814>;
        <D.25814>:
        tmp = remove;
        goto <D.25816>;
        <D.25815>:
        jlist.214 = jlist;
        jlist.214 = jlist;
        D.30968 = jlist.214->list;
        D.30969 = tmp->data;
        D.30970 = monoeg_g_slist_delete_link (D.30968, D.30969);
        jlist.214->list = D.30970;
        tmp = tmp->next;
        <D.25816>:
        if (tmp != 0B) goto <D.25815>; else goto <D.25817>;
        <D.25817>:
        monoeg_g_slist_free (remove);
      }
      <D.25819>:
      D.30971 = monoeg_g_hash_table_iter_next (&iter, 0B, &jlist);
      if (D.30971 != 0) goto <D.25818>; else goto <D.25820>;
      <D.25820>:
      {
        int ret;

        D.30928 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.30928);
        if (ret != 0) goto <D.30972>; else goto <D.30973>;
        <D.30972>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30973>:
        D.30974 = ret != 0;
        D.30975 = (long int) D.30974;
        D.30976 = __builtin_expect (D.30975, 0);
        if (D.30976 != 0) goto <D.30977>; else goto <D.30978>;
        <D.30977>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6315, "ret == 0");
        <D.30978>:
      }
      D.30959 = ji->ji;
      mono_jit_info_table_remove (domain, D.30959);
      if (destroy != 0) goto <D.30979>; else goto <D.30980>;
      <D.30979>:
      D.30981 = ji->code_mp;
      mono_code_manager_destroy (D.30981);
      <D.30980>:
      monoeg_g_free (ji);
    }
  finally
    {
      iter = {CLOBBER};
      jlist = {CLOBBER};
    }
}


mini_thread_cleanup (struct MonoInternalThread * thread)
{
  struct MonoInternalThread * D.30987;
  struct MonoLMF * D.30990;
  struct MonoJitTlsData * jit_tls;

  jit_tls = thread->jit_data;
  if (jit_tls != 0B) goto <D.30985>; else goto <D.30986>;
  <D.30985>:
  D.30987 = mono_thread_internal_current ();
  if (D.30987 == thread) goto <D.30988>; else goto <D.30989>;
  <D.30988>:
  mono_set_jit_tls (0B);
  <D.30989>:
  D.30990 = mono_get_lmf ();
  if (D.30990 != 0B) goto <D.30991>; else goto <D.30992>;
  <D.30991>:
  mono_set_lmf (0B);
  mono_set_lmf_addr (0B);
  <D.30992>:
  free_jit_tls_data (jit_tls);
  thread->jit_data = 0B;
  <D.30986>:
}


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

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


mini_get_imt_trampoline (int slot_index)
{
  void * D.30994;
  int D.30995;

  D.30995 = slot_index + -19;
  D.30994 = mini_get_vtable_trampoline (D.30995);
  return D.30994;
}


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

  D.30997 = descr;
  return D.30997;
}


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

  D.30999 = addr;
  return D.30999;
}


mini_parse_debug_options ()
{
  int D.25942;
  int iftmp.215;
  int D.25941;
  const char[14] * D.31006;
  unsigned char D.31007;
  int D.31008;
  unsigned char D.31009;
  int D.31010;
  const unsigned char * D.31015;
  unsigned char D.31016;
  int D.31017;
  const unsigned char * D.31018;
  unsigned char D.31019;
  int D.31020;
  const unsigned char * D.31025;
  unsigned char D.31026;
  int D.31027;
  const unsigned char * D.31028;
  unsigned char D.31029;
  int D.31030;
  const unsigned char * D.31035;
  unsigned char D.31036;
  int D.31037;
  const unsigned char * D.31038;
  unsigned char D.31039;
  int D.31040;
  int D.25951;
  int iftmp.216;
  int D.25950;
  const char[15] * D.31048;
  unsigned char D.31049;
  int D.31050;
  unsigned char D.31051;
  int D.31052;
  const unsigned char * D.31057;
  unsigned char D.31058;
  int D.31059;
  const unsigned char * D.31060;
  unsigned char D.31061;
  int D.31062;
  const unsigned char * D.31067;
  unsigned char D.31068;
  int D.31069;
  const unsigned char * D.31070;
  unsigned char D.31071;
  int D.31072;
  const unsigned char * D.31077;
  unsigned char D.31078;
  int D.31079;
  const unsigned char * D.31080;
  unsigned char D.31081;
  int D.31082;
  int D.25960;
  int iftmp.217;
  int D.25959;
  const char[27] * D.31090;
  unsigned char D.31091;
  int D.31092;
  unsigned char D.31093;
  int D.31094;
  const unsigned char * D.31099;
  unsigned char D.31100;
  int D.31101;
  const unsigned char * D.31102;
  unsigned char D.31103;
  int D.31104;
  const unsigned char * D.31109;
  unsigned char D.31110;
  int D.31111;
  const unsigned char * D.31112;
  unsigned char D.31113;
  int D.31114;
  const unsigned char * D.31119;
  unsigned char D.31120;
  int D.31121;
  const unsigned char * D.31122;
  unsigned char D.31123;
  int D.31124;
  int D.25969;
  int iftmp.218;
  int D.25968;
  const char[24] * D.31132;
  unsigned char D.31133;
  int D.31134;
  unsigned char D.31135;
  int D.31136;
  const unsigned char * D.31141;
  unsigned char D.31142;
  int D.31143;
  const unsigned char * D.31144;
  unsigned char D.31145;
  int D.31146;
  const unsigned char * D.31151;
  unsigned char D.31152;
  int D.31153;
  const unsigned char * D.31154;
  unsigned char D.31155;
  int D.31156;
  const unsigned char * D.31161;
  unsigned char D.31162;
  int D.31163;
  const unsigned char * D.31164;
  unsigned char D.31165;
  int D.31166;
  int D.25978;
  int iftmp.219;
  int D.25977;
  const char[20] * D.31174;
  unsigned char D.31175;
  int D.31176;
  unsigned char D.31177;
  int D.31178;
  const unsigned char * D.31183;
  unsigned char D.31184;
  int D.31185;
  const unsigned char * D.31186;
  unsigned char D.31187;
  int D.31188;
  const unsigned char * D.31193;
  unsigned char D.31194;
  int D.31195;
  const unsigned char * D.31196;
  unsigned char D.31197;
  int D.31198;
  const unsigned char * D.31203;
  unsigned char D.31204;
  int D.31205;
  const unsigned char * D.31206;
  unsigned char D.31207;
  int D.31208;
  int D.25987;
  int iftmp.220;
  int D.25986;
  const char[17] * D.31216;
  unsigned char D.31217;
  int D.31218;
  unsigned char D.31219;
  int D.31220;
  const unsigned char * D.31225;
  unsigned char D.31226;
  int D.31227;
  const unsigned char * D.31228;
  unsigned char D.31229;
  int D.31230;
  const unsigned char * D.31235;
  unsigned char D.31236;
  int D.31237;
  const unsigned char * D.31238;
  unsigned char D.31239;
  int D.31240;
  const unsigned char * D.31245;
  unsigned char D.31246;
  int D.31247;
  const unsigned char * D.31248;
  unsigned char D.31249;
  int D.31250;
  int D.25996;
  int iftmp.221;
  int D.25995;
  const char[19] * D.31258;
  unsigned char D.31259;
  int D.31260;
  unsigned char D.31261;
  int D.31262;
  const unsigned char * D.31267;
  unsigned char D.31268;
  int D.31269;
  const unsigned char * D.31270;
  unsigned char D.31271;
  int D.31272;
  const unsigned char * D.31277;
  unsigned char D.31278;
  int D.31279;
  const unsigned char * D.31280;
  unsigned char D.31281;
  int D.31282;
  const unsigned char * D.31287;
  unsigned char D.31288;
  int D.31289;
  const unsigned char * D.31290;
  unsigned char D.31291;
  int D.31292;
  int D.26005;
  int iftmp.222;
  int D.26004;
  const char[21] * D.31300;
  unsigned char D.31301;
  int D.31302;
  unsigned char D.31303;
  int D.31304;
  const unsigned char * D.31309;
  unsigned char D.31310;
  int D.31311;
  const unsigned char * D.31312;
  unsigned char D.31313;
  int D.31314;
  const unsigned char * D.31319;
  unsigned char D.31320;
  int D.31321;
  const unsigned char * D.31322;
  unsigned char D.31323;
  int D.31324;
  const unsigned char * D.31329;
  unsigned char D.31330;
  int D.31331;
  const unsigned char * D.31332;
  unsigned char D.31333;
  int D.31334;
  int D.26014;
  int iftmp.223;
  int D.26013;
  const char[18] * D.31342;
  unsigned char D.31343;
  int D.31344;
  unsigned char D.31345;
  int D.31346;
  const unsigned char * D.31351;
  unsigned char D.31352;
  int D.31353;
  const unsigned char * D.31354;
  unsigned char D.31355;
  int D.31356;
  const unsigned char * D.31361;
  unsigned char D.31362;
  int D.31363;
  const unsigned char * D.31364;
  unsigned char D.31365;
  int D.31366;
  const unsigned char * D.31371;
  unsigned char D.31372;
  int D.31373;
  const unsigned char * D.31374;
  unsigned char D.31375;
  int D.31376;
  int D.26023;
  int iftmp.224;
  int D.26022;
  const char[19] * D.31384;
  unsigned char D.31385;
  int D.31386;
  unsigned char D.31387;
  int D.31388;
  const unsigned char * D.31393;
  unsigned char D.31394;
  int D.31395;
  const unsigned char * D.31396;
  unsigned char D.31397;
  int D.31398;
  const unsigned char * D.31403;
  unsigned char D.31404;
  int D.31405;
  const unsigned char * D.31406;
  unsigned char D.31407;
  int D.31408;
  const unsigned char * D.31413;
  unsigned char D.31414;
  int D.31415;
  const unsigned char * D.31416;
  unsigned char D.31417;
  int D.31418;
  int D.26032;
  int iftmp.225;
  int D.26031;
  const char[4] * D.31426;
  unsigned char D.31427;
  int D.31428;
  unsigned char D.31429;
  int D.31430;
  const unsigned char * D.31435;
  unsigned char D.31436;
  int D.31437;
  const unsigned char * D.31438;
  unsigned char D.31439;
  int D.31440;
  const unsigned char * D.31445;
  unsigned char D.31446;
  int D.31447;
  const unsigned char * D.31448;
  unsigned char D.31449;
  int D.31450;
  const unsigned char * D.31455;
  unsigned char D.31456;
  int D.31457;
  const unsigned char * D.31458;
  unsigned char D.31459;
  int D.31460;
  int D.26041;
  int iftmp.226;
  int D.26040;
  const char[21] * D.31468;
  unsigned char D.31469;
  int D.31470;
  unsigned char D.31471;
  int D.31472;
  const unsigned char * D.31477;
  unsigned char D.31478;
  int D.31479;
  const unsigned char * D.31480;
  unsigned char D.31481;
  int D.31482;
  const unsigned char * D.31487;
  unsigned char D.31488;
  int D.31489;
  const unsigned char * D.31490;
  unsigned char D.31491;
  int D.31492;
  const unsigned char * D.31497;
  unsigned char D.31498;
  int D.31499;
  const unsigned char * D.31500;
  unsigned char D.31501;
  int D.31502;
  int D.26050;
  int iftmp.227;
  int D.26049;
  const char[15] * D.31510;
  unsigned char D.31511;
  int D.31512;
  unsigned char D.31513;
  int D.31514;
  const unsigned char * D.31519;
  unsigned char D.31520;
  int D.31521;
  const unsigned char * D.31522;
  unsigned char D.31523;
  int D.31524;
  const unsigned char * D.31529;
  unsigned char D.31530;
  int D.31531;
  const unsigned char * D.31532;
  unsigned char D.31533;
  int D.31534;
  const unsigned char * D.31539;
  unsigned char D.31540;
  int D.31541;
  const unsigned char * D.31542;
  unsigned char D.31543;
  int D.31544;
  int D.26059;
  int iftmp.228;
  int D.26058;
  const char[12] * D.31552;
  unsigned char D.31553;
  int D.31554;
  unsigned char D.31555;
  int D.31556;
  const unsigned char * D.31561;
  unsigned char D.31562;
  int D.31563;
  const unsigned char * D.31564;
  unsigned char D.31565;
  int D.31566;
  const unsigned char * D.31571;
  unsigned char D.31572;
  int D.31573;
  const unsigned char * D.31574;
  unsigned char D.31575;
  int D.31576;
  const unsigned char * D.31581;
  unsigned char D.31582;
  int D.31583;
  const unsigned char * D.31584;
  unsigned char D.31585;
  int D.31586;
  int D.26068;
  int iftmp.229;
  int D.26067;
  const char[6] * D.31594;
  unsigned char D.31595;
  int D.31596;
  unsigned char D.31597;
  int D.31598;
  const unsigned char * D.31603;
  unsigned char D.31604;
  int D.31605;
  const unsigned char * D.31606;
  unsigned char D.31607;
  int D.31608;
  const unsigned char * D.31613;
  unsigned char D.31614;
  int D.31615;
  const unsigned char * D.31616;
  unsigned char D.31617;
  int D.31618;
  const unsigned char * D.31623;
  unsigned char D.31624;
  int D.31625;
  const unsigned char * D.31626;
  unsigned char D.31627;
  int D.31628;
  int D.26077;
  int iftmp.230;
  int D.26076;
  const char[17] * D.31636;
  unsigned char D.31637;
  int D.31638;
  unsigned char D.31639;
  int D.31640;
  const unsigned char * D.31645;
  unsigned char D.31646;
  int D.31647;
  const unsigned char * D.31648;
  unsigned char D.31649;
  int D.31650;
  const unsigned char * D.31655;
  unsigned char D.31656;
  int D.31657;
  const unsigned char * D.31658;
  unsigned char D.31659;
  int D.31660;
  const unsigned char * D.31665;
  unsigned char D.31666;
  int D.31667;
  const unsigned char * D.31668;
  unsigned char D.31669;
  int D.31670;
  struct _IO_FILE * stderr.231;
  gchar * D.31677;
  const char * options;
  gchar * * args;
  gchar * * ptr;

  options = monoeg_g_getenv ("MONO_DEBUG");
  if (options == 0B) goto <D.31001>; else goto <D.31002>;
  <D.31001>:
  return;
  <D.31002>:
  args = monoeg_g_strsplit (options, ",", -1);
  ptr = args;
  goto <D.26079>;
  <D.26078>:
  {
    const char * arg;

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

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

        __s2 = arg;
        D.31006 = "handle-sigint";
        D.31007 = MEM[(const unsigned char *)D.31006];
        D.31008 = (int) D.31007;
        D.31009 = *__s2;
        D.31010 = (int) D.31009;
        __result = D.31008 - D.31010;
        {
          if (__s2_len != 0) goto <D.31011>; else goto <D.31012>;
          <D.31011>:
          if (__result == 0) goto <D.31013>; else goto <D.31014>;
          <D.31013>:
          D.31015 = &MEM[(void *)"handle-sigint" + 1B];
          D.31016 = *D.31015;
          D.31017 = (int) D.31016;
          D.31018 = __s2 + 1;
          D.31019 = *D.31018;
          D.31020 = (int) D.31019;
          __result = D.31017 - D.31020;
          if (__s2_len > 1) goto <D.31021>; else goto <D.31022>;
          <D.31021>:
          if (__result == 0) goto <D.31023>; else goto <D.31024>;
          <D.31023>:
          D.31025 = &MEM[(void *)"handle-sigint" + 2B];
          D.31026 = *D.31025;
          D.31027 = (int) D.31026;
          D.31028 = __s2 + 2;
          D.31029 = *D.31028;
          D.31030 = (int) D.31029;
          __result = D.31027 - D.31030;
          if (__s2_len > 2) goto <D.31031>; else goto <D.31032>;
          <D.31031>:
          if (__result == 0) goto <D.31033>; else goto <D.31034>;
          <D.31033>:
          D.31035 = &MEM[(void *)"handle-sigint" + 3B];
          D.31036 = *D.31035;
          D.31037 = (int) D.31036;
          D.31038 = __s2 + 3;
          D.31039 = *D.31038;
          D.31040 = (int) D.31039;
          __result = D.31037 - D.31040;
          <D.31034>:
          <D.31032>:
          <D.31024>:
          <D.31022>:
          <D.31014>:
          <D.31012>:
        }
        D.25941 = __result;
      }
      iftmp.215 = -D.25941;
      goto <D.31041>;
      <D.31005>:
      iftmp.215 = __builtin_strcmp (arg, "handle-sigint");
      <D.31041>:
      D.25942 = iftmp.215;
    }
    if (D.25942 == 0) goto <D.31042>; else goto <D.31043>;
    <D.31042>:
    debug_options.handle_sigint = 1;
    goto <D.31044>;
    <D.31043>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31048 = "keep-delegates";
        D.31049 = MEM[(const unsigned char *)D.31048];
        D.31050 = (int) D.31049;
        D.31051 = *__s2;
        D.31052 = (int) D.31051;
        __result = D.31050 - D.31052;
        {
          if (__s2_len != 0) goto <D.31053>; else goto <D.31054>;
          <D.31053>:
          if (__result == 0) goto <D.31055>; else goto <D.31056>;
          <D.31055>:
          D.31057 = &MEM[(void *)"keep-delegates" + 1B];
          D.31058 = *D.31057;
          D.31059 = (int) D.31058;
          D.31060 = __s2 + 1;
          D.31061 = *D.31060;
          D.31062 = (int) D.31061;
          __result = D.31059 - D.31062;
          if (__s2_len > 1) goto <D.31063>; else goto <D.31064>;
          <D.31063>:
          if (__result == 0) goto <D.31065>; else goto <D.31066>;
          <D.31065>:
          D.31067 = &MEM[(void *)"keep-delegates" + 2B];
          D.31068 = *D.31067;
          D.31069 = (int) D.31068;
          D.31070 = __s2 + 2;
          D.31071 = *D.31070;
          D.31072 = (int) D.31071;
          __result = D.31069 - D.31072;
          if (__s2_len > 2) goto <D.31073>; else goto <D.31074>;
          <D.31073>:
          if (__result == 0) goto <D.31075>; else goto <D.31076>;
          <D.31075>:
          D.31077 = &MEM[(void *)"keep-delegates" + 3B];
          D.31078 = *D.31077;
          D.31079 = (int) D.31078;
          D.31080 = __s2 + 3;
          D.31081 = *D.31080;
          D.31082 = (int) D.31081;
          __result = D.31079 - D.31082;
          <D.31076>:
          <D.31074>:
          <D.31066>:
          <D.31064>:
          <D.31056>:
          <D.31054>:
        }
        D.25950 = __result;
      }
      iftmp.216 = -D.25950;
      goto <D.31083>;
      <D.31047>:
      iftmp.216 = __builtin_strcmp (arg, "keep-delegates");
      <D.31083>:
      D.25951 = iftmp.216;
    }
    if (D.25951 == 0) goto <D.31084>; else goto <D.31085>;
    <D.31084>:
    debug_options.keep_delegates = 1;
    goto <D.31086>;
    <D.31085>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31090 = "reverse-pinvoke-exceptions";
        D.31091 = MEM[(const unsigned char *)D.31090];
        D.31092 = (int) D.31091;
        D.31093 = *__s2;
        D.31094 = (int) D.31093;
        __result = D.31092 - D.31094;
        {
          if (__s2_len != 0) goto <D.31095>; else goto <D.31096>;
          <D.31095>:
          if (__result == 0) goto <D.31097>; else goto <D.31098>;
          <D.31097>:
          D.31099 = &MEM[(void *)"reverse-pinvoke-exceptions" + 1B];
          D.31100 = *D.31099;
          D.31101 = (int) D.31100;
          D.31102 = __s2 + 1;
          D.31103 = *D.31102;
          D.31104 = (int) D.31103;
          __result = D.31101 - D.31104;
          if (__s2_len > 1) goto <D.31105>; else goto <D.31106>;
          <D.31105>:
          if (__result == 0) goto <D.31107>; else goto <D.31108>;
          <D.31107>:
          D.31109 = &MEM[(void *)"reverse-pinvoke-exceptions" + 2B];
          D.31110 = *D.31109;
          D.31111 = (int) D.31110;
          D.31112 = __s2 + 2;
          D.31113 = *D.31112;
          D.31114 = (int) D.31113;
          __result = D.31111 - D.31114;
          if (__s2_len > 2) goto <D.31115>; else goto <D.31116>;
          <D.31115>:
          if (__result == 0) goto <D.31117>; else goto <D.31118>;
          <D.31117>:
          D.31119 = &MEM[(void *)"reverse-pinvoke-exceptions" + 3B];
          D.31120 = *D.31119;
          D.31121 = (int) D.31120;
          D.31122 = __s2 + 3;
          D.31123 = *D.31122;
          D.31124 = (int) D.31123;
          __result = D.31121 - D.31124;
          <D.31118>:
          <D.31116>:
          <D.31108>:
          <D.31106>:
          <D.31098>:
          <D.31096>:
        }
        D.25959 = __result;
      }
      iftmp.217 = -D.25959;
      goto <D.31125>;
      <D.31089>:
      iftmp.217 = __builtin_strcmp (arg, "reverse-pinvoke-exceptions");
      <D.31125>:
      D.25960 = iftmp.217;
    }
    if (D.25960 == 0) goto <D.31126>; else goto <D.31127>;
    <D.31126>:
    debug_options.reverse_pinvoke_exceptions = 1;
    goto <D.31128>;
    <D.31127>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31132 = "collect-pagefault-stats";
        D.31133 = MEM[(const unsigned char *)D.31132];
        D.31134 = (int) D.31133;
        D.31135 = *__s2;
        D.31136 = (int) D.31135;
        __result = D.31134 - D.31136;
        {
          if (__s2_len != 0) goto <D.31137>; else goto <D.31138>;
          <D.31137>:
          if (__result == 0) goto <D.31139>; else goto <D.31140>;
          <D.31139>:
          D.31141 = &MEM[(void *)"collect-pagefault-stats" + 1B];
          D.31142 = *D.31141;
          D.31143 = (int) D.31142;
          D.31144 = __s2 + 1;
          D.31145 = *D.31144;
          D.31146 = (int) D.31145;
          __result = D.31143 - D.31146;
          if (__s2_len > 1) goto <D.31147>; else goto <D.31148>;
          <D.31147>:
          if (__result == 0) goto <D.31149>; else goto <D.31150>;
          <D.31149>:
          D.31151 = &MEM[(void *)"collect-pagefault-stats" + 2B];
          D.31152 = *D.31151;
          D.31153 = (int) D.31152;
          D.31154 = __s2 + 2;
          D.31155 = *D.31154;
          D.31156 = (int) D.31155;
          __result = D.31153 - D.31156;
          if (__s2_len > 2) goto <D.31157>; else goto <D.31158>;
          <D.31157>:
          if (__result == 0) goto <D.31159>; else goto <D.31160>;
          <D.31159>:
          D.31161 = &MEM[(void *)"collect-pagefault-stats" + 3B];
          D.31162 = *D.31161;
          D.31163 = (int) D.31162;
          D.31164 = __s2 + 3;
          D.31165 = *D.31164;
          D.31166 = (int) D.31165;
          __result = D.31163 - D.31166;
          <D.31160>:
          <D.31158>:
          <D.31150>:
          <D.31148>:
          <D.31140>:
          <D.31138>:
        }
        D.25968 = __result;
      }
      iftmp.218 = -D.25968;
      goto <D.31167>;
      <D.31131>:
      iftmp.218 = __builtin_strcmp (arg, "collect-pagefault-stats");
      <D.31167>:
      D.25969 = iftmp.218;
    }
    if (D.25969 == 0) goto <D.31168>; else goto <D.31169>;
    <D.31168>:
    debug_options.collect_pagefault_stats = 1;
    goto <D.31170>;
    <D.31169>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31174 = "break-on-unverified";
        D.31175 = MEM[(const unsigned char *)D.31174];
        D.31176 = (int) D.31175;
        D.31177 = *__s2;
        D.31178 = (int) D.31177;
        __result = D.31176 - D.31178;
        {
          if (__s2_len != 0) goto <D.31179>; else goto <D.31180>;
          <D.31179>:
          if (__result == 0) goto <D.31181>; else goto <D.31182>;
          <D.31181>:
          D.31183 = &MEM[(void *)"break-on-unverified" + 1B];
          D.31184 = *D.31183;
          D.31185 = (int) D.31184;
          D.31186 = __s2 + 1;
          D.31187 = *D.31186;
          D.31188 = (int) D.31187;
          __result = D.31185 - D.31188;
          if (__s2_len > 1) goto <D.31189>; else goto <D.31190>;
          <D.31189>:
          if (__result == 0) goto <D.31191>; else goto <D.31192>;
          <D.31191>:
          D.31193 = &MEM[(void *)"break-on-unverified" + 2B];
          D.31194 = *D.31193;
          D.31195 = (int) D.31194;
          D.31196 = __s2 + 2;
          D.31197 = *D.31196;
          D.31198 = (int) D.31197;
          __result = D.31195 - D.31198;
          if (__s2_len > 2) goto <D.31199>; else goto <D.31200>;
          <D.31199>:
          if (__result == 0) goto <D.31201>; else goto <D.31202>;
          <D.31201>:
          D.31203 = &MEM[(void *)"break-on-unverified" + 3B];
          D.31204 = *D.31203;
          D.31205 = (int) D.31204;
          D.31206 = __s2 + 3;
          D.31207 = *D.31206;
          D.31208 = (int) D.31207;
          __result = D.31205 - D.31208;
          <D.31202>:
          <D.31200>:
          <D.31192>:
          <D.31190>:
          <D.31182>:
          <D.31180>:
        }
        D.25977 = __result;
      }
      iftmp.219 = -D.25977;
      goto <D.31209>;
      <D.31173>:
      iftmp.219 = __builtin_strcmp (arg, "break-on-unverified");
      <D.31209>:
      D.25978 = iftmp.219;
    }
    if (D.25978 == 0) goto <D.31210>; else goto <D.31211>;
    <D.31210>:
    debug_options.break_on_unverified = 1;
    goto <D.31212>;
    <D.31211>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31216 = "no-gdb-backtrace";
        D.31217 = MEM[(const unsigned char *)D.31216];
        D.31218 = (int) D.31217;
        D.31219 = *__s2;
        D.31220 = (int) D.31219;
        __result = D.31218 - D.31220;
        {
          if (__s2_len != 0) goto <D.31221>; else goto <D.31222>;
          <D.31221>:
          if (__result == 0) goto <D.31223>; else goto <D.31224>;
          <D.31223>:
          D.31225 = &MEM[(void *)"no-gdb-backtrace" + 1B];
          D.31226 = *D.31225;
          D.31227 = (int) D.31226;
          D.31228 = __s2 + 1;
          D.31229 = *D.31228;
          D.31230 = (int) D.31229;
          __result = D.31227 - D.31230;
          if (__s2_len > 1) goto <D.31231>; else goto <D.31232>;
          <D.31231>:
          if (__result == 0) goto <D.31233>; else goto <D.31234>;
          <D.31233>:
          D.31235 = &MEM[(void *)"no-gdb-backtrace" + 2B];
          D.31236 = *D.31235;
          D.31237 = (int) D.31236;
          D.31238 = __s2 + 2;
          D.31239 = *D.31238;
          D.31240 = (int) D.31239;
          __result = D.31237 - D.31240;
          if (__s2_len > 2) goto <D.31241>; else goto <D.31242>;
          <D.31241>:
          if (__result == 0) goto <D.31243>; else goto <D.31244>;
          <D.31243>:
          D.31245 = &MEM[(void *)"no-gdb-backtrace" + 3B];
          D.31246 = *D.31245;
          D.31247 = (int) D.31246;
          D.31248 = __s2 + 3;
          D.31249 = *D.31248;
          D.31250 = (int) D.31249;
          __result = D.31247 - D.31250;
          <D.31244>:
          <D.31242>:
          <D.31234>:
          <D.31232>:
          <D.31224>:
          <D.31222>:
        }
        D.25986 = __result;
      }
      iftmp.220 = -D.25986;
      goto <D.31251>;
      <D.31215>:
      iftmp.220 = __builtin_strcmp (arg, "no-gdb-backtrace");
      <D.31251>:
      D.25987 = iftmp.220;
    }
    if (D.25987 == 0) goto <D.31252>; else goto <D.31253>;
    <D.31252>:
    debug_options.no_gdb_backtrace = 1;
    goto <D.31254>;
    <D.31253>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31258 = "suspend-on-sigsegv";
        D.31259 = MEM[(const unsigned char *)D.31258];
        D.31260 = (int) D.31259;
        D.31261 = *__s2;
        D.31262 = (int) D.31261;
        __result = D.31260 - D.31262;
        {
          if (__s2_len != 0) goto <D.31263>; else goto <D.31264>;
          <D.31263>:
          if (__result == 0) goto <D.31265>; else goto <D.31266>;
          <D.31265>:
          D.31267 = &MEM[(void *)"suspend-on-sigsegv" + 1B];
          D.31268 = *D.31267;
          D.31269 = (int) D.31268;
          D.31270 = __s2 + 1;
          D.31271 = *D.31270;
          D.31272 = (int) D.31271;
          __result = D.31269 - D.31272;
          if (__s2_len > 1) goto <D.31273>; else goto <D.31274>;
          <D.31273>:
          if (__result == 0) goto <D.31275>; else goto <D.31276>;
          <D.31275>:
          D.31277 = &MEM[(void *)"suspend-on-sigsegv" + 2B];
          D.31278 = *D.31277;
          D.31279 = (int) D.31278;
          D.31280 = __s2 + 2;
          D.31281 = *D.31280;
          D.31282 = (int) D.31281;
          __result = D.31279 - D.31282;
          if (__s2_len > 2) goto <D.31283>; else goto <D.31284>;
          <D.31283>:
          if (__result == 0) goto <D.31285>; else goto <D.31286>;
          <D.31285>:
          D.31287 = &MEM[(void *)"suspend-on-sigsegv" + 3B];
          D.31288 = *D.31287;
          D.31289 = (int) D.31288;
          D.31290 = __s2 + 3;
          D.31291 = *D.31290;
          D.31292 = (int) D.31291;
          __result = D.31289 - D.31292;
          <D.31286>:
          <D.31284>:
          <D.31276>:
          <D.31274>:
          <D.31266>:
          <D.31264>:
        }
        D.25995 = __result;
      }
      iftmp.221 = -D.25995;
      goto <D.31293>;
      <D.31257>:
      iftmp.221 = __builtin_strcmp (arg, "suspend-on-sigsegv");
      <D.31293>:
      D.25996 = iftmp.221;
    }
    if (D.25996 == 0) goto <D.31294>; else goto <D.31295>;
    <D.31294>:
    debug_options.suspend_on_sigsegv = 1;
    goto <D.31296>;
    <D.31295>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31300 = "suspend-on-unhandled";
        D.31301 = MEM[(const unsigned char *)D.31300];
        D.31302 = (int) D.31301;
        D.31303 = *__s2;
        D.31304 = (int) D.31303;
        __result = D.31302 - D.31304;
        {
          if (__s2_len != 0) goto <D.31305>; else goto <D.31306>;
          <D.31305>:
          if (__result == 0) goto <D.31307>; else goto <D.31308>;
          <D.31307>:
          D.31309 = &MEM[(void *)"suspend-on-unhandled" + 1B];
          D.31310 = *D.31309;
          D.31311 = (int) D.31310;
          D.31312 = __s2 + 1;
          D.31313 = *D.31312;
          D.31314 = (int) D.31313;
          __result = D.31311 - D.31314;
          if (__s2_len > 1) goto <D.31315>; else goto <D.31316>;
          <D.31315>:
          if (__result == 0) goto <D.31317>; else goto <D.31318>;
          <D.31317>:
          D.31319 = &MEM[(void *)"suspend-on-unhandled" + 2B];
          D.31320 = *D.31319;
          D.31321 = (int) D.31320;
          D.31322 = __s2 + 2;
          D.31323 = *D.31322;
          D.31324 = (int) D.31323;
          __result = D.31321 - D.31324;
          if (__s2_len > 2) goto <D.31325>; else goto <D.31326>;
          <D.31325>:
          if (__result == 0) goto <D.31327>; else goto <D.31328>;
          <D.31327>:
          D.31329 = &MEM[(void *)"suspend-on-unhandled" + 3B];
          D.31330 = *D.31329;
          D.31331 = (int) D.31330;
          D.31332 = __s2 + 3;
          D.31333 = *D.31332;
          D.31334 = (int) D.31333;
          __result = D.31331 - D.31334;
          <D.31328>:
          <D.31326>:
          <D.31318>:
          <D.31316>:
          <D.31308>:
          <D.31306>:
        }
        D.26004 = __result;
      }
      iftmp.222 = -D.26004;
      goto <D.31335>;
      <D.31299>:
      iftmp.222 = __builtin_strcmp (arg, "suspend-on-unhandled");
      <D.31335>:
      D.26005 = iftmp.222;
    }
    if (D.26005 == 0) goto <D.31336>; else goto <D.31337>;
    <D.31336>:
    debug_options.suspend_on_unhandled = 1;
    goto <D.31338>;
    <D.31337>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31342 = "dont-free-domains";
        D.31343 = MEM[(const unsigned char *)D.31342];
        D.31344 = (int) D.31343;
        D.31345 = *__s2;
        D.31346 = (int) D.31345;
        __result = D.31344 - D.31346;
        {
          if (__s2_len != 0) goto <D.31347>; else goto <D.31348>;
          <D.31347>:
          if (__result == 0) goto <D.31349>; else goto <D.31350>;
          <D.31349>:
          D.31351 = &MEM[(void *)"dont-free-domains" + 1B];
          D.31352 = *D.31351;
          D.31353 = (int) D.31352;
          D.31354 = __s2 + 1;
          D.31355 = *D.31354;
          D.31356 = (int) D.31355;
          __result = D.31353 - D.31356;
          if (__s2_len > 1) goto <D.31357>; else goto <D.31358>;
          <D.31357>:
          if (__result == 0) goto <D.31359>; else goto <D.31360>;
          <D.31359>:
          D.31361 = &MEM[(void *)"dont-free-domains" + 2B];
          D.31362 = *D.31361;
          D.31363 = (int) D.31362;
          D.31364 = __s2 + 2;
          D.31365 = *D.31364;
          D.31366 = (int) D.31365;
          __result = D.31363 - D.31366;
          if (__s2_len > 2) goto <D.31367>; else goto <D.31368>;
          <D.31367>:
          if (__result == 0) goto <D.31369>; else goto <D.31370>;
          <D.31369>:
          D.31371 = &MEM[(void *)"dont-free-domains" + 3B];
          D.31372 = *D.31371;
          D.31373 = (int) D.31372;
          D.31374 = __s2 + 3;
          D.31375 = *D.31374;
          D.31376 = (int) D.31375;
          __result = D.31373 - D.31376;
          <D.31370>:
          <D.31368>:
          <D.31360>:
          <D.31358>:
          <D.31350>:
          <D.31348>:
        }
        D.26013 = __result;
      }
      iftmp.223 = -D.26013;
      goto <D.31377>;
      <D.31341>:
      iftmp.223 = __builtin_strcmp (arg, "dont-free-domains");
      <D.31377>:
      D.26014 = iftmp.223;
    }
    if (D.26014 == 0) goto <D.31378>; else goto <D.31379>;
    <D.31378>:
    mono_dont_free_domains = 1;
    goto <D.31380>;
    <D.31379>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31384 = "dyn-runtime-invoke";
        D.31385 = MEM[(const unsigned char *)D.31384];
        D.31386 = (int) D.31385;
        D.31387 = *__s2;
        D.31388 = (int) D.31387;
        __result = D.31386 - D.31388;
        {
          if (__s2_len != 0) goto <D.31389>; else goto <D.31390>;
          <D.31389>:
          if (__result == 0) goto <D.31391>; else goto <D.31392>;
          <D.31391>:
          D.31393 = &MEM[(void *)"dyn-runtime-invoke" + 1B];
          D.31394 = *D.31393;
          D.31395 = (int) D.31394;
          D.31396 = __s2 + 1;
          D.31397 = *D.31396;
          D.31398 = (int) D.31397;
          __result = D.31395 - D.31398;
          if (__s2_len > 1) goto <D.31399>; else goto <D.31400>;
          <D.31399>:
          if (__result == 0) goto <D.31401>; else goto <D.31402>;
          <D.31401>:
          D.31403 = &MEM[(void *)"dyn-runtime-invoke" + 2B];
          D.31404 = *D.31403;
          D.31405 = (int) D.31404;
          D.31406 = __s2 + 2;
          D.31407 = *D.31406;
          D.31408 = (int) D.31407;
          __result = D.31405 - D.31408;
          if (__s2_len > 2) goto <D.31409>; else goto <D.31410>;
          <D.31409>:
          if (__result == 0) goto <D.31411>; else goto <D.31412>;
          <D.31411>:
          D.31413 = &MEM[(void *)"dyn-runtime-invoke" + 3B];
          D.31414 = *D.31413;
          D.31415 = (int) D.31414;
          D.31416 = __s2 + 3;
          D.31417 = *D.31416;
          D.31418 = (int) D.31417;
          __result = D.31415 - D.31418;
          <D.31412>:
          <D.31410>:
          <D.31402>:
          <D.31400>:
          <D.31392>:
          <D.31390>:
        }
        D.26022 = __result;
      }
      iftmp.224 = -D.26022;
      goto <D.31419>;
      <D.31383>:
      iftmp.224 = __builtin_strcmp (arg, "dyn-runtime-invoke");
      <D.31419>:
      D.26023 = iftmp.224;
    }
    if (D.26023 == 0) goto <D.31420>; else goto <D.31421>;
    <D.31420>:
    debug_options.dyn_runtime_invoke = 1;
    goto <D.31422>;
    <D.31421>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31426 = "gdb";
        D.31427 = MEM[(const unsigned char *)D.31426];
        D.31428 = (int) D.31427;
        D.31429 = *__s2;
        D.31430 = (int) D.31429;
        __result = D.31428 - D.31430;
        {
          if (__s2_len != 0) goto <D.31431>; else goto <D.31432>;
          <D.31431>:
          if (__result == 0) goto <D.31433>; else goto <D.31434>;
          <D.31433>:
          D.31435 = &MEM[(void *)"gdb" + 1B];
          D.31436 = *D.31435;
          D.31437 = (int) D.31436;
          D.31438 = __s2 + 1;
          D.31439 = *D.31438;
          D.31440 = (int) D.31439;
          __result = D.31437 - D.31440;
          if (__s2_len > 1) goto <D.31441>; else goto <D.31442>;
          <D.31441>:
          if (__result == 0) goto <D.31443>; else goto <D.31444>;
          <D.31443>:
          D.31445 = &MEM[(void *)"gdb" + 2B];
          D.31446 = *D.31445;
          D.31447 = (int) D.31446;
          D.31448 = __s2 + 2;
          D.31449 = *D.31448;
          D.31450 = (int) D.31449;
          __result = D.31447 - D.31450;
          if (__s2_len > 2) goto <D.31451>; else goto <D.31452>;
          <D.31451>:
          if (__result == 0) goto <D.31453>; else goto <D.31454>;
          <D.31453>:
          D.31455 = &MEM[(void *)"gdb" + 3B];
          D.31456 = *D.31455;
          D.31457 = (int) D.31456;
          D.31458 = __s2 + 3;
          D.31459 = *D.31458;
          D.31460 = (int) D.31459;
          __result = D.31457 - D.31460;
          <D.31454>:
          <D.31452>:
          <D.31444>:
          <D.31442>:
          <D.31434>:
          <D.31432>:
        }
        D.26031 = __result;
      }
      iftmp.225 = -D.26031;
      goto <D.31461>;
      <D.31425>:
      iftmp.225 = __builtin_strcmp (arg, "gdb");
      <D.31461>:
      D.26032 = iftmp.225;
    }
    if (D.26032 == 0) goto <D.31462>; else goto <D.31463>;
    <D.31462>:
    debug_options.gdb = 1;
    goto <D.31464>;
    <D.31463>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31468 = "explicit-null-checks";
        D.31469 = MEM[(const unsigned char *)D.31468];
        D.31470 = (int) D.31469;
        D.31471 = *__s2;
        D.31472 = (int) D.31471;
        __result = D.31470 - D.31472;
        {
          if (__s2_len != 0) goto <D.31473>; else goto <D.31474>;
          <D.31473>:
          if (__result == 0) goto <D.31475>; else goto <D.31476>;
          <D.31475>:
          D.31477 = &MEM[(void *)"explicit-null-checks" + 1B];
          D.31478 = *D.31477;
          D.31479 = (int) D.31478;
          D.31480 = __s2 + 1;
          D.31481 = *D.31480;
          D.31482 = (int) D.31481;
          __result = D.31479 - D.31482;
          if (__s2_len > 1) goto <D.31483>; else goto <D.31484>;
          <D.31483>:
          if (__result == 0) goto <D.31485>; else goto <D.31486>;
          <D.31485>:
          D.31487 = &MEM[(void *)"explicit-null-checks" + 2B];
          D.31488 = *D.31487;
          D.31489 = (int) D.31488;
          D.31490 = __s2 + 2;
          D.31491 = *D.31490;
          D.31492 = (int) D.31491;
          __result = D.31489 - D.31492;
          if (__s2_len > 2) goto <D.31493>; else goto <D.31494>;
          <D.31493>:
          if (__result == 0) goto <D.31495>; else goto <D.31496>;
          <D.31495>:
          D.31497 = &MEM[(void *)"explicit-null-checks" + 3B];
          D.31498 = *D.31497;
          D.31499 = (int) D.31498;
          D.31500 = __s2 + 3;
          D.31501 = *D.31500;
          D.31502 = (int) D.31501;
          __result = D.31499 - D.31502;
          <D.31496>:
          <D.31494>:
          <D.31486>:
          <D.31484>:
          <D.31476>:
          <D.31474>:
        }
        D.26040 = __result;
      }
      iftmp.226 = -D.26040;
      goto <D.31503>;
      <D.31467>:
      iftmp.226 = __builtin_strcmp (arg, "explicit-null-checks");
      <D.31503>:
      D.26041 = iftmp.226;
    }
    if (D.26041 == 0) goto <D.31504>; else goto <D.31505>;
    <D.31504>:
    debug_options.explicit_null_checks = 1;
    goto <D.31506>;
    <D.31505>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31510 = "gen-seq-points";
        D.31511 = MEM[(const unsigned char *)D.31510];
        D.31512 = (int) D.31511;
        D.31513 = *__s2;
        D.31514 = (int) D.31513;
        __result = D.31512 - D.31514;
        {
          if (__s2_len != 0) goto <D.31515>; else goto <D.31516>;
          <D.31515>:
          if (__result == 0) goto <D.31517>; else goto <D.31518>;
          <D.31517>:
          D.31519 = &MEM[(void *)"gen-seq-points" + 1B];
          D.31520 = *D.31519;
          D.31521 = (int) D.31520;
          D.31522 = __s2 + 1;
          D.31523 = *D.31522;
          D.31524 = (int) D.31523;
          __result = D.31521 - D.31524;
          if (__s2_len > 1) goto <D.31525>; else goto <D.31526>;
          <D.31525>:
          if (__result == 0) goto <D.31527>; else goto <D.31528>;
          <D.31527>:
          D.31529 = &MEM[(void *)"gen-seq-points" + 2B];
          D.31530 = *D.31529;
          D.31531 = (int) D.31530;
          D.31532 = __s2 + 2;
          D.31533 = *D.31532;
          D.31534 = (int) D.31533;
          __result = D.31531 - D.31534;
          if (__s2_len > 2) goto <D.31535>; else goto <D.31536>;
          <D.31535>:
          if (__result == 0) goto <D.31537>; else goto <D.31538>;
          <D.31537>:
          D.31539 = &MEM[(void *)"gen-seq-points" + 3B];
          D.31540 = *D.31539;
          D.31541 = (int) D.31540;
          D.31542 = __s2 + 3;
          D.31543 = *D.31542;
          D.31544 = (int) D.31543;
          __result = D.31541 - D.31544;
          <D.31538>:
          <D.31536>:
          <D.31528>:
          <D.31526>:
          <D.31518>:
          <D.31516>:
        }
        D.26049 = __result;
      }
      iftmp.227 = -D.26049;
      goto <D.31545>;
      <D.31509>:
      iftmp.227 = __builtin_strcmp (arg, "gen-seq-points");
      <D.31545>:
      D.26050 = iftmp.227;
    }
    if (D.26050 == 0) goto <D.31546>; else goto <D.31547>;
    <D.31546>:
    debug_options.gen_seq_points = 1;
    goto <D.31548>;
    <D.31547>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.31552 = "init-stacks";
        D.31553 = MEM[(const unsigned char *)D.31552];
        D.31554 = (int) D.31553;
        D.31555 = *__s2;
        D.31556 = (int) D.31555;
        __result = D.31554 - D.31556;
        {
          if (__s2_len != 0) goto <D.31557>; else goto <D.31558>;
          <D.31557>:
          if (__result == 0) goto <D.31559>; else goto <D.31560>;
          <D.31559>:
          D.31561 = &MEM[(void *)"init-stacks" + 1B];
          D.31562 = *D.31561;
          D.31563 = (int) D.31562;
          D.31564 = __s2 + 1;
          D.31565 = *D.31564;
          D.31566 = (int) D.31565;
          __result = D.31563 - D.31566;
          if (__s2_len > 1) goto <D.31567>; else goto <D.31568>;
          <D.31567>:
          if (__result == 0) goto <D.31569>; else goto <D.31570>;
          <D.31569>:
          D.31571 = &MEM[(void *)"init-stacks" + 2B];
          D.31572 = *D.31571;
          D.31573 = (int) D.31572;
          D.31574 = __s2 + 2;
          D.31575 = *D.31574;
          D.31576 = (int) D.31575;
          __result = D.31573 - D.31576;
          if (__s2_len > 2) goto <D.31577>; else goto <D.31578>;
          <D.31577>:
          if (__result == 0) goto <D.31579>; else goto <D.31580>;
          <D.31579>:
          D.31581 = &MEM[(void *)"init-stacks" + 3B];
          D.31582 = *D.31581;
          D.31583 = (int) D.31582;
          D.31584 = __s2 + 3;
          D.31585 = *D.31584;
          D.31586 = (int) D.31585;
          __result = D.31583 - D.31586;
          <D.31580>:
          <D.31578>:
          <D.31570>:
          <D.31568>:
          <D.31560>:
          <D.31558>:
        }
        D.26058 = __result;
      }
      iftmp.228 = -D.26058;
      goto <D.31587>;
      <D.31551>:
      iftmp.228 = __builtin_strcmp (arg, "init-stacks");
      <D.31587>:
      D.26059 = iftmp.228;
    }
    if (D.26059 == 0) goto <D.31588>; else goto <D.31589>;
    <D.31588>:
    debug_options.init_stacks = 1;
    goto <D.31590>;
    <D.31589>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

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

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

        __s2 = arg;
        D.31636 = "soft-breakpoints";
        D.31637 = MEM[(const unsigned char *)D.31636];
        D.31638 = (int) D.31637;
        D.31639 = *__s2;
        D.31640 = (int) D.31639;
        __result = D.31638 - D.31640;
        {
          if (__s2_len != 0) goto <D.31641>; else goto <D.31642>;
          <D.31641>:
          if (__result == 0) goto <D.31643>; else goto <D.31644>;
          <D.31643>:
          D.31645 = &MEM[(void *)"soft-breakpoints" + 1B];
          D.31646 = *D.31645;
          D.31647 = (int) D.31646;
          D.31648 = __s2 + 1;
          D.31649 = *D.31648;
          D.31650 = (int) D.31649;
          __result = D.31647 - D.31650;
          if (__s2_len > 1) goto <D.31651>; else goto <D.31652>;
          <D.31651>:
          if (__result == 0) goto <D.31653>; else goto <D.31654>;
          <D.31653>:
          D.31655 = &MEM[(void *)"soft-breakpoints" + 2B];
          D.31656 = *D.31655;
          D.31657 = (int) D.31656;
          D.31658 = __s2 + 2;
          D.31659 = *D.31658;
          D.31660 = (int) D.31659;
          __result = D.31657 - D.31660;
          if (__s2_len > 2) goto <D.31661>; else goto <D.31662>;
          <D.31661>:
          if (__result == 0) goto <D.31663>; else goto <D.31664>;
          <D.31663>:
          D.31665 = &MEM[(void *)"soft-breakpoints" + 3B];
          D.31666 = *D.31665;
          D.31667 = (int) D.31666;
          D.31668 = __s2 + 3;
          D.31669 = *D.31668;
          D.31670 = (int) D.31669;
          __result = D.31667 - D.31670;
          <D.31664>:
          <D.31662>:
          <D.31654>:
          <D.31652>:
          <D.31644>:
          <D.31642>:
        }
        D.26076 = __result;
      }
      iftmp.230 = -D.26076;
      goto <D.31671>;
      <D.31635>:
      iftmp.230 = __builtin_strcmp (arg, "soft-breakpoints");
      <D.31671>:
      D.26077 = iftmp.230;
    }
    if (D.26077 == 0) goto <D.31672>; else goto <D.31673>;
    <D.31672>:
    debug_options.soft_breakpoints = 1;
    goto <D.31674>;
    <D.31673>:
    stderr.231 = stderr;
    fprintf (stderr.231, "Invalid option for the MONO_DEBUG env variable: %s\n", arg);
    stderr.231 = stderr;
    fprintf (stderr.231, "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.31674>:
    <D.31632>:
    <D.31590>:
    <D.31548>:
    <D.31506>:
    <D.31464>:
    <D.31422>:
    <D.31380>:
    <D.31338>:
    <D.31296>:
    <D.31254>:
    <D.31212>:
    <D.31170>:
    <D.31128>:
    <D.31086>:
    <D.31044>:
  }
  ptr = ptr + 4;
  <D.26079>:
  if (ptr != 0B) goto <D.31676>; else goto <D.26080>;
  <D.31676>:
  D.31677 = *ptr;
  if (D.31677 != 0B) goto <D.26078>; else goto <D.26080>;
  <D.26080>:
  monoeg_g_strfreev (args);
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.31679;
  void (*<Tc3>) (void *) destructor.232;
  int D.31681;
  _Bool D.31682;

  destructor.232 = (void (*<Tc3>) (void *)) destructor;
  D.31681 = pthread_key_create (key, destructor.232);
  D.31682 = D.31681 == 0;
  D.31679 = (int) D.31682;
  return D.31679;
}


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.31684>; else goto <D.31685>;
  <D.31684>:
  sig = mono_create_icall_signature (sigstr);
  goto <D.31686>;
  <D.31685>:
  sig = 0B;
  <D.31686>:
  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 int D.31687;
  unsigned int D.31688;
  _Bool D.31689;
  long int D.31690;
  long int D.31691;
  short unsigned int D.31694;
  _Bool D.31695;
  long int D.31696;
  long int D.31697;
  short int emul_opcode_num.233;
  short int emul_opcode_alloced.234;
  int iftmp.235;
  short int D.31707;
  unsigned short D.31709;
  unsigned short emul_opcode_alloced.236;
  unsigned short D.31711;
  short int emul_opcode_alloced.237;
  struct MonoJitICallInfo * * emul_opcode_map.238;
  unsigned int D.31714;
  unsigned int D.31715;
  void * emul_opcode_map.239;
  short int * emul_opcode_opcodes.240;
  unsigned int D.31718;
  void * emul_opcode_opcodes.241;
  unsigned int D.31720;
  unsigned int D.31721;
  struct MonoJitICallInfo * * D.31722;
  unsigned int D.31723;
  short int * D.31724;
  short int D.31725;
  short int emul_opcode_num.242;
  unsigned short emul_opcode_num.243;
  unsigned short D.31728;
  short int emul_opcode_num.244;
  int D.31730;
  unsigned char D.31731;
  signed char D.31732;
  int D.31733;
  int D.31734;
  signed char D.31735;
  signed char D.31736;
  unsigned char D.31737;
  struct MonoJitICallInfo * info;
  struct MonoMethodSignature * sig;

  sig = mono_create_icall_signature (sigstr);
  D.31687 = BIT_FIELD_REF <*sig, 32, 64>;
  D.31688 = D.31687 & 4194304;
  D.31689 = D.31688 != 0;
  D.31690 = (long int) D.31689;
  D.31691 = __builtin_expect (D.31690, 0);
  if (D.31691 != 0) goto <D.31692>; else goto <D.31693>;
  <D.31692>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2373, "!sig->hasthis");
  <D.31693>:
  D.31694 = sig->param_count;
  D.31695 = D.31694 > 2;
  D.31696 = (long int) D.31695;
  D.31697 = __builtin_expect (D.31696, 0);
  if (D.31697 != 0) goto <D.31698>; else goto <D.31699>;
  <D.31698>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2374, "sig->param_count < 3");
  <D.31699>:
  info = mono_register_jit_icall_full (func, name, sig, no_throw, symbol);
  emul_opcode_num.233 = emul_opcode_num;
  emul_opcode_alloced.234 = emul_opcode_alloced;
  if (emul_opcode_num.233 >= emul_opcode_alloced.234) goto <D.31702>; else goto <D.31703>;
  <D.31702>:
  {
    int incr;

    emul_opcode_alloced.234 = emul_opcode_alloced;
    if (emul_opcode_alloced.234 != 0) goto <D.31705>; else goto <D.31706>;
    <D.31705>:
    emul_opcode_alloced.234 = emul_opcode_alloced;
    D.31707 = emul_opcode_alloced.234 / 2;
    iftmp.235 = (int) D.31707;
    goto <D.31708>;
    <D.31706>:
    iftmp.235 = 16;
    <D.31708>:
    incr = iftmp.235;
    D.31709 = (unsigned short) incr;
    emul_opcode_alloced.234 = emul_opcode_alloced;
    emul_opcode_alloced.236 = (unsigned short) emul_opcode_alloced.234;
    D.31711 = D.31709 + emul_opcode_alloced.236;
    emul_opcode_alloced.237 = (short int) D.31711;
    emul_opcode_alloced = emul_opcode_alloced.237;
    emul_opcode_map.238 = emul_opcode_map;
    emul_opcode_alloced.234 = emul_opcode_alloced;
    D.31714 = (unsigned int) emul_opcode_alloced.234;
    D.31715 = D.31714 * 4;
    emul_opcode_map.239 = monoeg_realloc (emul_opcode_map.238, D.31715);
    emul_opcode_map = emul_opcode_map.239;
    emul_opcode_opcodes.240 = emul_opcode_opcodes;
    emul_opcode_alloced.234 = emul_opcode_alloced;
    D.31714 = (unsigned int) emul_opcode_alloced.234;
    D.31718 = D.31714 * 2;
    emul_opcode_opcodes.241 = monoeg_realloc (emul_opcode_opcodes.240, D.31718);
    emul_opcode_opcodes = emul_opcode_opcodes.241;
  }
  <D.31703>:
  emul_opcode_map.238 = emul_opcode_map;
  emul_opcode_num.233 = emul_opcode_num;
  D.31720 = (unsigned int) emul_opcode_num.233;
  D.31721 = D.31720 * 4;
  D.31722 = emul_opcode_map.238 + D.31721;
  *D.31722 = info;
  emul_opcode_opcodes.240 = emul_opcode_opcodes;
  emul_opcode_num.233 = emul_opcode_num;
  D.31720 = (unsigned int) emul_opcode_num.233;
  D.31723 = D.31720 * 2;
  D.31724 = emul_opcode_opcodes.240 + D.31723;
  D.31725 = (short int) opcode;
  *D.31724 = D.31725;
  emul_opcode_num.233 = emul_opcode_num;
  emul_opcode_num.242 = emul_opcode_num.233;
  emul_opcode_num.243 = (unsigned short) emul_opcode_num.242;
  D.31728 = emul_opcode_num.243 + 1;
  emul_opcode_num.244 = (short int) D.31728;
  emul_opcode_num = emul_opcode_num.244;
  D.31730 = opcode >> 6;
  D.31730 = opcode >> 6;
  D.31731 = emul_opcode_hit_cache[D.31730];
  D.31732 = (signed char) D.31731;
  D.31733 = opcode & 7;
  D.31734 = 1 << D.31733;
  D.31735 = (signed char) D.31734;
  D.31736 = D.31732 | D.31735;
  D.31737 = (unsigned char) D.31736;
  emul_opcode_hit_cache[D.31730] = D.31737;
}


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

  if (sigstr != 0B) goto <D.31738>; else goto <D.31739>;
  <D.31738>:
  sig = mono_create_icall_signature (sigstr);
  goto <D.31740>;
  <D.31739>:
  sig = 0B;
  <D.31740>:
  if (save != 0) goto <D.31742>; else goto <D.31743>;
  <D.31742>:
  iftmp.245 = name;
  goto <D.31744>;
  <D.31743>:
  iftmp.245 = 0B;
  <D.31744>:
  mono_register_jit_icall_full (func, name, sig, save, iftmp.245);
}


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

  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.246 = mono_jit_tls_id;
  D.31746 = pthread_getspecific (mono_jit_tls_id.246);
  free_jit_tls_data (D.31746);
  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.247 = mono_dont_free_global_codeman;
  if (mono_dont_free_global_codeman.247 == 0) goto <D.31748>; else goto <D.31749>;
  <D.31748>:
  global_codeman.248 = global_codeman;
  mono_code_manager_destroy (global_codeman.248);
  <D.31749>:
  jit_icall_name_hash.249 = jit_icall_name_hash;
  monoeg_g_hash_table_destroy (jit_icall_name_hash.249);
  emul_opcode_map.250 = emul_opcode_map;
  monoeg_g_free (emul_opcode_map.250);
  emul_opcode_opcodes.251 = emul_opcode_opcodes;
  monoeg_g_free (emul_opcode_opcodes.251);
  vtable_trampolines.252 = vtable_trampolines;
  monoeg_g_free (vtable_trampolines.252);
  mono_arch_cleanup ();
  mono_generic_sharing_cleanup ();
  mono_cleanup ();
  mono_trace_cleanup ();
  stdout.253 = stdout;
  mono_counters_dump (-1, stdout.253);
  mono_inject_async_exc_method.254 = mono_inject_async_exc_method;
  if (mono_inject_async_exc_method.254 != 0B) goto <D.31757>; else goto <D.31758>;
  <D.31757>:
  mono_inject_async_exc_method.254 = mono_inject_async_exc_method;
  mono_method_desc_free (mono_inject_async_exc_method.254);
  <D.31758>:
  mono_jit_tls_id.246 = mono_jit_tls_id;
  mono_native_tls_free (mono_jit_tls_id.246);
  DeleteCriticalSection (&jit_mutex);
  DeleteCriticalSection (&mono_delegate_section);
  mono_code_manager_cleanup ();
}


print_jit_stats ()
{
  int D.31759;
  int D.31762;
  double D.31763;
  double D.31764;
  char * D.31765;
  int D.31766;
  char * D.31767;
  long unsigned int D.31768;
  long unsigned int D.31769;
  long unsigned int D.31770;
  long unsigned int D.31771;
  long unsigned int D.31772;
  long unsigned int D.31773;
  long unsigned int D.31774;
  struct MonoImage * D.31775;
  struct MonoMemPool * D.31776;
  unsigned int D.31777;
  long unsigned int D.31778;
  long unsigned int D.31779;
  int D.31780;
  long unsigned int D.31781;
  long unsigned int D.31782;
  long unsigned int D.31783;
  long unsigned int D.31784;
  long unsigned int D.31785;
  long unsigned int D.31786;
  long unsigned int D.31787;
  long unsigned int D.31788;
  long unsigned int D.31789;
  long unsigned int D.31790;
  long unsigned int D.31791;
  long unsigned int D.31792;
  long unsigned int D.31793;
  long unsigned int D.31794;
  long unsigned int D.31795;
  long unsigned int D.31796;
  long unsigned int D.31797;
  long unsigned int D.31798;
  long unsigned int D.31799;
  <unnamed type> D.31800;
  int D.31803;
  int D.31804;
  int D.31805;
  int D.31806;
  int D.31807;
  int D.31808;

  D.31759 = mono_jit_stats.enabled;
  if (D.31759 != 0) goto <D.31760>; else goto <D.31761>;
  <D.31760>:
  monoeg_g_print ("Mono Jit statistics\n");
  D.31762 = mono_jit_stats.max_code_size_ratio;
  D.31763 = (double) D.31762;
  D.31764 = D.31763 / 1.0e+2;
  D.31765 = mono_jit_stats.max_ratio_method;
  monoeg_g_print ("Max code size ratio:    %.2f (%s)\n", D.31764, D.31765);
  D.31766 = mono_jit_stats.biggest_method_size;
  D.31767 = mono_jit_stats.biggest_method;
  monoeg_g_print ("Biggest method:         %ld (%s)\n", D.31766, D.31767);
  D.31768 = mono_stats.delegate_creations;
  monoeg_g_print ("Delegates created:      %ld\n", D.31768);
  D.31769 = mono_stats.initialized_class_count;
  monoeg_g_print ("Initialized classes:    %ld\n", D.31769);
  D.31770 = mono_stats.used_class_count;
  monoeg_g_print ("Used classes:           %ld\n", D.31770);
  D.31771 = mono_stats.generic_vtable_count;
  monoeg_g_print ("Generic vtables:        %ld\n", D.31771);
  D.31772 = mono_stats.method_count;
  monoeg_g_print ("Methods:                %ld\n", D.31772);
  D.31773 = mono_stats.class_static_data_size;
  monoeg_g_print ("Static data size:       %ld\n", D.31773);
  D.31774 = mono_stats.class_vtable_size;
  monoeg_g_print ("VTable data size:       %ld\n", D.31774);
  D.31775 = mono_defaults.corlib;
  D.31776 = D.31775->mempool;
  D.31777 = mono_mempool_get_allocated (D.31776);
  monoeg_g_print ("Mscorlib mempool size:  %d\n", D.31777);
  D.31778 = mono_stats.generic_class_count;
  monoeg_g_print ("\nInitialized classes:    %ld\n", D.31778);
  D.31779 = mono_stats.inflated_type_count;
  monoeg_g_print ("Inflated types:         %ld\n", D.31779);
  D.31780 = mono_jit_stats.generic_virtual_invocations;
  monoeg_g_print ("Generics virtual invokes: %ld\n", D.31780);
  D.31781 = mono_stats.generics_sharable_methods;
  monoeg_g_print ("Sharable generic methods: %ld\n", D.31781);
  D.31782 = mono_stats.generics_unsharable_methods;
  monoeg_g_print ("Unsharable generic methods: %ld\n", D.31782);
  D.31783 = mono_stats.generics_shared_methods;
  monoeg_g_print ("Shared generic methods: %ld\n", D.31783);
  D.31784 = mono_stats.gsharedvt_methods;
  monoeg_g_print ("Shared vtype generic methods: %ld\n", D.31784);
  D.31785 = mono_stats.dynamic_code_alloc_count;
  monoeg_g_print ("Dynamic code allocs:    %ld\n", D.31785);
  D.31786 = mono_stats.dynamic_code_bytes_count;
  monoeg_g_print ("Dynamic code bytes:     %ld\n", D.31786);
  D.31787 = mono_stats.dynamic_code_frees_count;
  monoeg_g_print ("Dynamic code frees:     %ld\n", D.31787);
  D.31788 = mono_stats.imt_tables_size;
  monoeg_g_print ("IMT tables size:        %ld\n", D.31788);
  D.31789 = mono_stats.imt_number_of_tables;
  monoeg_g_print ("IMT number of tables:   %ld\n", D.31789);
  D.31790 = mono_stats.imt_number_of_methods;
  monoeg_g_print ("IMT number of methods:  %ld\n", D.31790);
  D.31791 = mono_stats.imt_used_slots;
  monoeg_g_print ("IMT used slots:         %ld\n", D.31791);
  D.31792 = mono_stats.imt_slots_with_collisions;
  monoeg_g_print ("IMT colliding slots:    %ld\n", D.31792);
  D.31793 = mono_stats.imt_max_collisions_in_slot;
  monoeg_g_print ("IMT max collisions:     %ld\n", D.31793);
  D.31794 = mono_stats.imt_method_count_when_max_collisions;
  monoeg_g_print ("IMT methods at max col: %ld\n", D.31794);
  D.31795 = mono_stats.imt_thunks_size;
  monoeg_g_print ("IMT thunks size:        %ld\n", D.31795);
  D.31796 = mono_stats.jit_info_table_insert_count;
  monoeg_g_print ("JIT info table inserts: %ld\n", D.31796);
  D.31797 = mono_stats.jit_info_table_remove_count;
  monoeg_g_print ("JIT info table removes: %ld\n", D.31797);
  D.31798 = mono_stats.jit_info_table_lookup_count;
  monoeg_g_print ("JIT info table lookups: %ld\n", D.31798);
  D.31799 = mono_stats.hazardous_pointer_count;
  monoeg_g_print ("Hazardous pointers:     %ld\n", D.31799);
  D.31800 = mono_security_get_mode ();
  if (D.31800 == 2) goto <D.31801>; else goto <D.31802>;
  <D.31801>:
  D.31803 = mono_jit_stats.cas_declsec_check;
  monoeg_g_print ("\nDecl security check   : %ld\n", D.31803);
  D.31804 = mono_jit_stats.cas_linkdemand;
  monoeg_g_print ("LinkDemand (user)     : %ld\n", D.31804);
  D.31805 = mono_jit_stats.cas_linkdemand_icall;
  monoeg_g_print ("LinkDemand (icall)    : %ld\n", D.31805);
  D.31806 = mono_jit_stats.cas_linkdemand_pinvoke;
  monoeg_g_print ("LinkDemand (pinvoke)  : %ld\n", D.31806);
  D.31807 = mono_jit_stats.cas_linkdemand_aptc;
  monoeg_g_print ("LinkDemand (aptc)     : %ld\n", D.31807);
  D.31808 = mono_jit_stats.cas_demand_generation;
  monoeg_g_print ("Demand (code gen)     : %ld\n", D.31808);
  <D.31802>:
  D.31765 = mono_jit_stats.max_ratio_method;
  monoeg_g_free (D.31765);
  mono_jit_stats.max_ratio_method = 0B;
  D.31767 = mono_jit_stats.biggest_method;
  monoeg_g_free (D.31767);
  mono_jit_stats.biggest_method = 0B;
  <D.31761>:
}


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.31809;
  unsigned int default_opt.255;
  unsigned int default_opt.256;

  D.31809 = ~opts;
  default_opt.255 = default_opt;
  default_opt.256 = D.31809 & default_opt.255;
  default_opt = default_opt.256;
}


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


mono_set_verbose_level (guint32 level)
{
  int level.257;

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


mono_get_runtime_build_info ()
{
  const char * mono_build_date.258;
  char * D.31816;

  mono_build_date.258 = mono_build_date;
  if (mono_build_date.258 != 0B) goto <D.31814>; else goto <D.31815>;
  <D.31814>:
  mono_build_date.258 = mono_build_date;
  D.31816 = monoeg_g_strdup_printf ("%s (%s %s)", "3.2.8", "Debian 3.2.8+dfsg-10", mono_build_date.258);
  return D.31816;
  <D.31815>:
  D.31816 = monoeg_g_strdup_printf ("%s (%s)", "3.2.8", "Debian 3.2.8+dfsg-10");
  return D.31816;
}


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.31818;
  int mini_verbose.259;
  const char * D.31824;
  int D.31825;
  int D.31826;
  unsigned int D.31827;
  short unsigned int D.31828;
  int D.31829;
  int D.31830;
  int D.26189;
  int iftmp.260;
  int D.26188;
  const char[9] * D.31838;
  unsigned char D.31839;
  int D.31840;
  unsigned char D.31841;
  int D.31842;
  const unsigned char * D.31847;
  unsigned char D.31848;
  int D.31849;
  const unsigned char * D.31850;
  unsigned char D.31851;
  int D.31852;
  const unsigned char * D.31857;
  unsigned char D.31858;
  int D.31859;
  const unsigned char * D.31860;
  unsigned char D.31861;
  int D.31862;
  const unsigned char * D.31867;
  unsigned char D.31868;
  int D.31869;
  const unsigned char * D.31870;
  unsigned char D.31871;
  int D.31872;
  const char * D.31874;
  struct MonoClass * D.31877;
  unsigned int D.31878;
  unsigned int D.31879;
  struct MonoMethodSignature * D.31882;
  unsigned int D.31883;
  unsigned int D.31884;
  int D.31887;
  struct MonoAssembly * * D.31888;
  unsigned int i.261;
  unsigned int D.31890;
  struct MonoAssembly * * D.31891;
  struct MonoAssembly * D.31892;
  int D.31895;
  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.31818 = monoeg_g_hash_table_lookup (assemblies, ass);
  if (D.31818 != 0B) goto <D.31819>; else goto <D.31820>;
  <D.31819>:
  return;
  <D.31820>:
  monoeg_g_hash_table_insert_replace (assemblies, ass, ass, 0);
  mini_verbose.259 = mini_verbose;
  if (mini_verbose.259 > 0) goto <D.31822>; else goto <D.31823>;
  <D.31822>:
  D.31824 = mono_image_get_filename (image);
  printf ("PRECOMPILE: %s.\n", D.31824);
  <D.31823>:
  i = 0;
  goto <D.26191>;
  <D.26190>:
  D.31825 = i + 1;
  D.31826 = D.31825 | 100663296;
  D.31827 = (unsigned int) D.31826;
  method = mono_get_method (image, D.31827, 0B);
  D.31828 = method->flags;
  D.31829 = (int) D.31828;
  D.31830 = D.31829 & 1024;
  if (D.31830 != 0) goto <D.31831>; else goto <D.31832>;
  <D.31831>:
  // predicted unlikely by continue predictor.
  goto <D.26179>;
  <D.31832>:
  count = count + 1;
  mini_verbose.259 = mini_verbose;
  if (mini_verbose.259 > 1) goto <D.31833>; else goto <D.31834>;
  <D.31833>:
  {
    char * desc;

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

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

      __s2 = method->name;
      D.31838 = "Finalize";
      D.31839 = MEM[(const unsigned char *)D.31838];
      D.31840 = (int) D.31839;
      D.31841 = *__s2;
      D.31842 = (int) D.31841;
      __result = D.31840 - D.31842;
      {
        if (__s2_len != 0) goto <D.31843>; else goto <D.31844>;
        <D.31843>:
        if (__result == 0) goto <D.31845>; else goto <D.31846>;
        <D.31845>:
        D.31847 = &MEM[(void *)"Finalize" + 1B];
        D.31848 = *D.31847;
        D.31849 = (int) D.31848;
        D.31850 = __s2 + 1;
        D.31851 = *D.31850;
        D.31852 = (int) D.31851;
        __result = D.31849 - D.31852;
        if (__s2_len > 1) goto <D.31853>; else goto <D.31854>;
        <D.31853>:
        if (__result == 0) goto <D.31855>; else goto <D.31856>;
        <D.31855>:
        D.31857 = &MEM[(void *)"Finalize" + 2B];
        D.31858 = *D.31857;
        D.31859 = (int) D.31858;
        D.31860 = __s2 + 2;
        D.31861 = *D.31860;
        D.31862 = (int) D.31861;
        __result = D.31859 - D.31862;
        if (__s2_len > 2) goto <D.31863>; else goto <D.31864>;
        <D.31863>:
        if (__result == 0) goto <D.31865>; else goto <D.31866>;
        <D.31865>:
        D.31867 = &MEM[(void *)"Finalize" + 3B];
        D.31868 = *D.31867;
        D.31869 = (int) D.31868;
        D.31870 = __s2 + 3;
        D.31871 = *D.31870;
        D.31872 = (int) D.31871;
        __result = D.31869 - D.31872;
        <D.31866>:
        <D.31864>:
        <D.31856>:
        <D.31854>:
        <D.31846>:
        <D.31844>:
      }
      D.26188 = __result;
    }
    iftmp.260 = -D.26188;
    goto <D.31873>;
    <D.31837>:
    D.31874 = method->name;
    iftmp.260 = __builtin_strcmp (D.31874, "Finalize");
    <D.31873>:
    D.26189 = iftmp.260;
  }
  if (D.26189 == 0) goto <D.31875>; else goto <D.31876>;
  <D.31875>:
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  mono_compile_method (invoke);
  <D.31876>:
  D.31877 = method->klass;
  D.31878 = BIT_FIELD_REF <*D.31877, 32, 160>;
  D.31879 = D.31878 & 4194304;
  if (D.31879 != 0) goto <D.31880>; else goto <D.31881>;
  <D.31880>:
  D.31882 = mono_method_signature (method);
  D.31883 = BIT_FIELD_REF <*D.31882, 32, 64>;
  D.31884 = D.31883 & 4194304;
  if (D.31884 != 0) goto <D.31885>; else goto <D.31886>;
  <D.31885>:
  invoke = mono_marshal_get_remoting_invoke_with_check (method);
  mono_compile_method (invoke);
  <D.31886>:
  <D.31881>:
  <D.26179>:
  i = i + 1;
  <D.26191>:
  D.31887 = mono_image_get_table_rows (image, 6);
  if (D.31887 > i) goto <D.26190>; else goto <D.26192>;
  <D.26192>:
  i = 0;
  goto <D.26194>;
  <D.26193>:
  mono_assembly_load_reference (image, i);
  D.31888 = image->references;
  i.261 = (unsigned int) i;
  D.31890 = i.261 * 4;
  D.31891 = D.31888 + D.31890;
  D.31892 = *D.31891;
  if (D.31892 != 0B) goto <D.31893>; else goto <D.31894>;
  <D.31893>:
  D.31888 = image->references;
  i.261 = (unsigned int) i;
  D.31890 = i.261 * 4;
  D.31891 = D.31888 + D.31890;
  D.31892 = *D.31891;
  mono_precompile_assembly (D.31892, assemblies);
  <D.31894>:
  i = i + 1;
  <D.26194>:
  D.31895 = mono_image_get_table_rows (image, 35);
  if (D.31895 > i) goto <D.26193>; else goto <D.26195>;
  <D.26195>:
}


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

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


mono_cfg_add_try_hole (struct MonoCompile * cfg, struct MonoExceptionClause * clause, guint8 * start, struct MonoBasicBlock * bb)
{
  struct MonoMemPool * D.31899;
  int start.262;
  unsigned char * D.31901;
  int D.31902;
  int D.31903;
  struct GSList * D.31904;
  struct GSList * D.31905;
  struct TryBlockHole * hole;

  D.31899 = cfg->mempool;
  hole = mono_mempool_alloc (D.31899, 12);
  hole->clause = clause;
  start.262 = (int) start;
  D.31901 = cfg->native_code;
  D.31902 = (int) D.31901;
  D.31903 = start.262 - D.31902;
  hole->start_offset = D.31903;
  hole->basic_block = bb;
  D.31899 = cfg->mempool;
  D.31904 = cfg->try_block_holes;
  D.31905 = g_slist_append_mempool (D.31899, D.31904, hole);
  cfg->try_block_holes = D.31905;
}


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

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


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

  D.31907 = 0;
  return D.31907;
}


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

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


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

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


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

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


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

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