mini_gc_enable_gc_maps_for_aot ()
{
  enable_gc_maps_for_aot = 1;
}


mini_gc_set_slot_type_from_fp (struct MonoCompile * cfg, int slot_offset, GCSlotType type)
{
  unsigned char D.25457;
  unsigned char D.25458;
  unsigned int slot_offset.0;
  unsigned int D.25462;
  _Bool D.25463;
  long int D.25464;
  long int D.25465;
  struct MonoMemPool * D.25468;
  struct GSList * D.25469;
  int D.25470;
  unsigned int D.25471;
  unsigned int D.25472;
  void * D.25473;
  struct GSList * D.25474;
  struct MonoCompileGC * gcfg;

  gcfg = cfg->gc_info;
  D.25457 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.25458 = D.25457 & 128;
  if (D.25458 == 0) goto <D.25459>; else goto <D.25460>;
  <D.25459>:
  return;
  <D.25460>:
  slot_offset.0 = (unsigned int) slot_offset;
  D.25462 = slot_offset.0 & 3;
  D.25463 = D.25462 != 0;
  D.25464 = (long int) D.25463;
  D.25465 = __builtin_expect (D.25464, 0);
  if (D.25465 != 0) goto <D.25466>; else goto <D.25467>;
  <D.25466>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 1279, "slot_offset % SIZEOF_SLOT == 0");
  <D.25467>:
  D.25468 = cfg->mempool;
  D.25469 = gcfg->stack_slots_from_fp;
  D.25470 = slot_offset << 16;
  D.25471 = (unsigned int) D.25470;
  D.25472 = D.25471 | type;
  D.25473 = (void *) D.25472;
  D.25474 = g_slist_prepend_mempool (D.25468, D.25469, D.25473);
  gcfg->stack_slots_from_fp = D.25474;
}


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

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


mini_gc_set_slot_type_from_cfa (struct MonoCompile * cfg, int slot_offset, GCSlotType type)
{
  unsigned char D.25478;
  unsigned char D.25479;
  _Bool D.25482;
  long int D.25483;
  long int D.25484;
  unsigned int slot_offset.1;
  unsigned int D.25488;
  _Bool D.25489;
  long int D.25490;
  long int D.25491;
  struct MonoMemPool * D.25494;
  struct GSList * D.25495;
  int D.25496;
  unsigned int D.25497;
  unsigned int D.25498;
  void * D.25499;
  struct GSList * D.25500;
  struct MonoCompileGC * gcfg;
  int slot;

  gcfg = cfg->gc_info;
  slot = slot_offset / -4;
  D.25478 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.25479 = D.25478 & 128;
  if (D.25479 == 0) goto <D.25480>; else goto <D.25481>;
  <D.25480>:
  return;
  <D.25481>:
  D.25482 = slot_offset > 0;
  D.25483 = (long int) D.25482;
  D.25484 = __builtin_expect (D.25483, 0);
  if (D.25484 != 0) goto <D.25485>; else goto <D.25486>;
  <D.25485>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 1302, "slot_offset <= 0");
  <D.25486>:
  slot_offset.1 = (unsigned int) slot_offset;
  D.25488 = slot_offset.1 & 3;
  D.25489 = D.25488 != 0;
  D.25490 = (long int) D.25489;
  D.25491 = __builtin_expect (D.25490, 0);
  if (D.25491 != 0) goto <D.25492>; else goto <D.25493>;
  <D.25492>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 1303, "slot_offset % SIZEOF_SLOT == 0");
  <D.25493>:
  D.25494 = cfg->mempool;
  D.25495 = gcfg->stack_slots_from_cfa;
  D.25496 = slot << 16;
  D.25497 = (unsigned int) D.25496;
  D.25498 = D.25497 | type;
  D.25499 = (void *) D.25498;
  D.25500 = g_slist_prepend_mempool (D.25494, D.25495, D.25499);
  gcfg->stack_slots_from_cfa = D.25500;
}


mini_gc_create_gc_map (struct MonoCompile * cfg)
{
  unsigned char D.25502;
  unsigned char D.25503;
  unsigned int D.25506;
  unsigned int D.25507;

  D.25502 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.25503 = D.25502 & 128;
  if (D.25503 == 0) goto <D.25504>; else goto <D.25505>;
  <D.25504>:
  return;
  <D.25505>:
  D.25506 = cfg->comp_done;
  D.25507 = D.25506 & 16;
  if (D.25507 == 0) goto <D.25508>; else goto <D.25509>;
  <D.25508>:
  return;
  <D.25509>:
  mono_analyze_liveness_gc (cfg);
  compute_frame_size (cfg);
  init_gcfg (cfg);
  process_spill_slots (cfg);
  process_other_slots (cfg);
  process_param_area_slots (cfg);
  process_variables (cfg);
  process_finally_clauses (cfg);
  create_map (cfg);
}


compute_frame_size (struct MonoCompile * cfg)
{
  struct MonoMethod * D.25511;
  int D.25512;
  int D.25513;
  int D.25514;
  int D.25515;
  struct MonoInst * * D.25516;
  unsigned int i.2;
  unsigned int D.25518;
  struct MonoInst * * D.25519;
  short unsigned int D.25520;
  struct MonoGenericSharingContext * D.25523;
  struct MonoType * D.25524;
  int D.25525;
  int D.25526;
  int D.25527;
  int D.25528;
  int D.25529;
  short unsigned int D.25530;
  int D.25531;
  <unnamed-unsigned:1> D.25532;
  int D.25533;
  int D.25534;
  unsigned int D.25535;
  int D.25536;
  unsigned int D.25537;
  _Bool D.25538;
  long int D.25539;
  long int D.25540;
  int D.25543;
  _Bool D.25544;
  long int D.25545;
  long int D.25546;
  void * D.25549;
  unsigned int D.25550;
  unsigned int D.25551;
  int D.25554;
  int D.25555;
  int D.25556;
  int i;
  int locals_min_offset;
  int locals_max_offset;
  int cfa_min_offset;
  int cfa_max_offset;
  int min_offset;
  int max_offset;
  struct MonoCompileGC * gcfg;
  struct MonoMethodSignature * sig;
  struct GSList * l;

  gcfg = cfg->gc_info;
  D.25511 = cfg->method;
  sig = mono_method_signature (D.25511);
  D.25512 = cfg->locals_min_stack_offset;
  D.25513 = D.25512 + 3;
  locals_min_offset = D.25513 & -4;
  locals_max_offset = cfg->locals_max_stack_offset;
  D.25514 = locals_min_offset + 3;
  locals_min_offset = D.25514 & -4;
  D.25515 = locals_max_offset + 3;
  locals_max_offset = D.25515 & -4;
  min_offset = locals_min_offset;
  max_offset = locals_max_offset;
  i = 0;
  goto <D.25305>;
  <D.25304>:
  {
    struct MonoInst * ins;

    D.25516 = cfg->args;
    i.2 = (unsigned int) i;
    D.25518 = i.2 * 4;
    D.25519 = D.25516 + D.25518;
    ins = *D.25519;
    D.25520 = ins->opcode;
    if (D.25520 == 367) goto <D.25521>; else goto <D.25522>;
    <D.25521>:
    {
      int size;
      int size_in_slots;

      D.25523 = cfg->generic_sharing_context;
      D.25524 = ins->data.op[1].vtype;
      D.25525 = ins->backend.is_pinvoke;
      size = mini_type_stack_size_full (D.25523, D.25524, 0B, D.25525);
      D.25526 = size + 3;
      size_in_slots = D.25526 >> 2;
      D.25527 = ins->data.op[0].const_val;
      min_offset = MIN_EXPR <D.25527, min_offset>;
      D.25527 = ins->data.op[0].const_val;
      D.25528 = size_in_slots * 4;
      D.25529 = D.25527 + D.25528;
      max_offset = MAX_EXPR <D.25529, max_offset>;
    }
    <D.25522>:
  }
  i = i + 1;
  <D.25305>:
  D.25530 = sig->param_count;
  D.25531 = (int) D.25530;
  D.25532 = sig->hasthis;
  D.25533 = (int) D.25532;
  D.25534 = D.25531 + D.25533;
  if (D.25534 > i) goto <D.25304>; else goto <D.25306>;
  <D.25306>:
  D.25535 = cfg->frame_reg;
  D.25536 = cfg->cfa_reg;
  D.25537 = (unsigned int) D.25536;
  D.25538 = D.25535 != D.25537;
  D.25539 = (long int) D.25538;
  D.25540 = __builtin_expect (D.25539, 0);
  if (D.25540 != 0) goto <D.25541>; else goto <D.25542>;
  <D.25541>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 2030, "cfg->frame_reg == cfg->cfa_reg");
  <D.25542>:
  D.25543 = cfg->cfa_offset;
  D.25544 = D.25543 <= 0;
  D.25545 = (long int) D.25544;
  D.25546 = __builtin_expect (D.25545, 0);
  if (D.25546 != 0) goto <D.25547>; else goto <D.25548>;
  <D.25547>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 2031, "cfg->cfa_offset > 0");
  <D.25548>:
  cfa_min_offset = 0;
  cfa_max_offset = cfg->cfa_offset;
  min_offset = MIN_EXPR <cfa_min_offset, min_offset>;
  max_offset = MAX_EXPR <cfa_max_offset, max_offset>;
  l = gcfg->stack_slots_from_fp;
  goto <D.25310>;
  <D.25309>:
  {
    gint data;
    int offset;

    D.25549 = l->data;
    data = (gint) D.25549;
    offset = data >> 16;
    min_offset = MIN_EXPR <offset, min_offset>;
  }
  l = l->next;
  <D.25310>:
  if (l != 0B) goto <D.25309>; else goto <D.25311>;
  <D.25311>:
  D.25550 = cfg->flags;
  D.25551 = D.25550 & 64;
  if (D.25551 == 0) goto <D.25552>; else goto <D.25553>;
  <D.25552>:
  {
    int stack_offset;

    D.25554 = cfg->stack_offset;
    D.25555 = D.25554 + 3;
    stack_offset = D.25555 & -4;
    D.25556 = -stack_offset;
    min_offset = MIN_EXPR <D.25556, min_offset>;
  }
  <D.25553>:
  gcfg->min_offset = min_offset;
  gcfg->max_offset = max_offset;
  gcfg->locals_min_offset = locals_min_offset;
  gcfg->locals_max_offset = locals_max_offset;
}


init_gcfg (struct MonoCompile * cfg)
{
  struct GSList * D.25557;
  unsigned int D.25558;
  unsigned int ncallsites.3;
  unsigned int D.25560;
  struct MonoMemPool * D.25561;
  unsigned int ncallsites.4;
  unsigned int D.25563;
  int i.5;
  unsigned int i.6;
  unsigned int D.25566;
  struct GCCallSite * * D.25567;
  void * D.25568;
  sizetype i.7;
  sizetype D.25570;
  sizetype D.25571;
  struct GCCallSite * * D.25572;
  struct GCCallSite * D.25573;
  int D.25574;
  unsigned int i.8;
  unsigned int D.25576;
  struct GCCallSite * * D.25577;
  struct GCCallSite * D.25578;
  int D.25579;
  _Bool D.25580;
  long int D.25581;
  long int D.25582;
  unsigned int D.25585;
  struct MonoMethod * D.25588;
  char * D.25589;
  int D.25590;
  int D.25591;
  int D.25592;
  int D.25593;
  int D.25594;
  int D.25595;
  int D.25596;
  unsigned int D.25597;
  void * D.25598;
  void * D.25599;
  int D.25600;
  int D.25601;
  unsigned int D.25602;
  void * D.25603;
  void * D.25604;
  guint8 * D.25605;
  int D.25606;
  unsigned int D.25607;
  unsigned int D.25608;
  int D.25609;
  unsigned int D.25610;
  unsigned int D.25611;
  int i;
  int nregs;
  int nslots;
  struct MonoCompileGC * gcfg;
  struct GCCallSite * * callsites;
  int ncallsites;
  struct MonoBasicBlock * bb;
  struct GSList * l;

  gcfg = cfg->gc_info;
  ncallsites = 0;
  bb = cfg->bb_entry;
  goto <D.25325>;
  <D.25324>:
  D.25557 = bb->gc_callsites;
  D.25558 = monoeg_g_slist_length (D.25557);
  ncallsites.3 = (unsigned int) ncallsites;
  D.25560 = D.25558 + ncallsites.3;
  ncallsites = (int) D.25560;
  bb = bb->next_bb;
  <D.25325>:
  if (bb != 0B) goto <D.25324>; else goto <D.25326>;
  <D.25326>:
  D.25561 = cfg->mempool;
  ncallsites.4 = (unsigned int) ncallsites;
  D.25563 = ncallsites.4 * 4;
  callsites = mono_mempool_alloc0 (D.25561, D.25563);
  i = 0;
  bb = cfg->bb_entry;
  goto <D.25331>;
  <D.25330>:
  l = bb->gc_callsites;
  goto <D.25328>;
  <D.25327>:
  i.5 = i;
  i = i.5 + 1;
  i.6 = (unsigned int) i.5;
  D.25566 = i.6 * 4;
  D.25567 = callsites + D.25566;
  D.25568 = l->data;
  *D.25567 = D.25568;
  l = l->next;
  <D.25328>:
  if (l != 0B) goto <D.25327>; else goto <D.25329>;
  <D.25329>:
  bb = bb->next_bb;
  <D.25331>:
  if (bb != 0B) goto <D.25330>; else goto <D.25332>;
  <D.25332>:
  i = 1;
  goto <D.25334>;
  <D.25333>:
  i.7 = (sizetype) i;
  D.25570 = i.7 + 1073741823;
  D.25571 = D.25570 * 4;
  D.25572 = callsites + D.25571;
  D.25573 = *D.25572;
  D.25574 = D.25573->pc_offset;
  i.8 = (unsigned int) i;
  D.25576 = i.8 * 4;
  D.25577 = callsites + D.25576;
  D.25578 = *D.25577;
  D.25579 = D.25578->pc_offset;
  D.25580 = D.25574 >= D.25579;
  D.25581 = (long int) D.25580;
  D.25582 = __builtin_expect (D.25581, 0);
  if (D.25582 != 0) goto <D.25583>; else goto <D.25584>;
  <D.25583>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 2097, "callsites [i - 1]->pc_offset < callsites [i]->pc_offset");
  <D.25584>:
  i = i + 1;
  <D.25334>:
  if (i < ncallsites) goto <D.25333>; else goto <D.25335>;
  <D.25335>:
  D.25585 = cfg->verbose_level;
  if (D.25585 > 1) goto <D.25586>; else goto <D.25587>;
  <D.25586>:
  D.25588 = cfg->method;
  D.25589 = mono_method_full_name (D.25588, 1);
  D.25590 = gcfg->min_offset;
  D.25591 = gcfg->max_offset;
  printf ("GC Map for %s: 0x%x-0x%x\n", D.25589, D.25590, D.25591);
  <D.25587>:
  D.25591 = gcfg->max_offset;
  D.25590 = gcfg->min_offset;
  D.25592 = D.25591 - D.25590;
  nslots = D.25592 / 4;
  nregs = 16;
  gcfg->nslots = nslots;
  gcfg->nregs = nregs;
  gcfg->callsites = callsites;
  gcfg->ncallsites = ncallsites;
  D.25593 = ncallsites + 7;
  D.25594 = D.25593 >> 3;
  gcfg->stack_bitmap_width = D.25594;
  D.25593 = ncallsites + 7;
  D.25594 = D.25593 >> 3;
  gcfg->reg_bitmap_width = D.25594;
  D.25561 = cfg->mempool;
  D.25595 = gcfg->stack_bitmap_width;
  D.25596 = D.25595 * nslots;
  D.25597 = (unsigned int) D.25596;
  D.25598 = mono_mempool_alloc0 (D.25561, D.25597);
  gcfg->stack_ref_bitmap = D.25598;
  D.25561 = cfg->mempool;
  D.25595 = gcfg->stack_bitmap_width;
  D.25596 = D.25595 * nslots;
  D.25597 = (unsigned int) D.25596;
  D.25599 = mono_mempool_alloc0 (D.25561, D.25597);
  gcfg->stack_pin_bitmap = D.25599;
  D.25561 = cfg->mempool;
  D.25600 = gcfg->reg_bitmap_width;
  D.25601 = D.25600 * nregs;
  D.25602 = (unsigned int) D.25601;
  D.25603 = mono_mempool_alloc0 (D.25561, D.25602);
  gcfg->reg_ref_bitmap = D.25603;
  D.25561 = cfg->mempool;
  D.25600 = gcfg->reg_bitmap_width;
  D.25601 = D.25600 * nregs;
  D.25602 = (unsigned int) D.25601;
  D.25604 = mono_mempool_alloc0 (D.25561, D.25602);
  gcfg->reg_pin_bitmap = D.25604;
  D.25605 = gcfg->stack_pin_bitmap;
  D.25595 = gcfg->stack_bitmap_width;
  D.25606 = D.25595 * nregs;
  D.25607 = (unsigned int) D.25606;
  memset (D.25605, 255, D.25607);
  i = 0;
  goto <D.25337>;
  <D.25336>:
  D.25608 = cfg->used_int_regs;
  D.25609 = 1 << i;
  D.25610 = (unsigned int) D.25609;
  D.25611 = D.25608 & D.25610;
  if (D.25611 != 0) goto <D.25612>; else goto <D.25613>;
  <D.25612>:
  set_reg_slot_everywhere (gcfg, i, 0);
  <D.25613>:
  i = i + 1;
  <D.25337>:
  if (i < nregs) goto <D.25336>; else goto <D.25338>;
  <D.25338>:
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.25618;
  int D.25623;
  void * D.25625;
  unsigned int D.25626;

  D.25618 = __builtin_constant_p (__len);
  if (D.25618 != 0) goto <D.25619>; else goto <D.25620>;
  <D.25619>:
  if (__len == 0) goto <D.25621>; else goto <D.25622>;
  <D.25621>:
  D.25623 = __builtin_constant_p (__ch);
  if (D.25623 == 0) goto <D.25616>; else goto <D.25624>;
  <D.25624>:
  if (__ch != 0) goto <D.25616>; else goto <D.25617>;
  <D.25616>:
  __warn_memset_zero_len ();
  D.25625 = __dest;
  return D.25625;
  <D.25617>:
  <D.25622>:
  <D.25620>:
  D.25626 = __builtin_object_size (__dest, 0);
  D.25625 = __builtin___memset_chk (__dest, __ch, __len, D.25626);
  return D.25625;
}


set_reg_slot_everywhere (struct MonoCompileGC * gcfg, int slot, GCSlotType type)
{
  int D.25628;
  int cindex;

  cindex = 0;
  goto <D.25075>;
  <D.25074>:
  set_reg_slot (gcfg, slot, cindex, type);
  cindex = cindex + 1;
  <D.25075>:
  D.25628 = gcfg->ncallsites;
  if (D.25628 > cindex) goto <D.25074>; else goto <D.25076>;
  <D.25076>:
}


set_reg_slot (struct MonoCompileGC * gcfg, int slot, int callsite_index, GCSlotType type)
{
  int iftmp.9;
  int D.25634;
  _Bool D.25635;
  long int D.25636;
  long int D.25637;
  guint8 * D.25642;
  int D.25643;
  guint8 * D.25644;

  if (slot < 0) goto <D.25630>; else goto <D.25633>;
  <D.25633>:
  D.25634 = gcfg->nregs;
  if (D.25634 <= slot) goto <D.25630>; else goto <D.25631>;
  <D.25630>:
  iftmp.9 = 1;
  goto <D.25632>;
  <D.25631>:
  iftmp.9 = 0;
  <D.25632>:
  D.25635 = iftmp.9 != 0;
  D.25636 = (long int) D.25635;
  D.25637 = __builtin_expect (D.25636, 0);
  if (D.25637 != 0) goto <D.25638>; else goto <D.25639>;
  <D.25638>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 1385, "slot >= 0 && slot < gcfg->nregs");
  <D.25639>:
  if (type == 2) goto <D.25640>; else goto <D.25641>;
  <D.25640>:
  D.25642 = gcfg->reg_ref_bitmap;
  D.25643 = gcfg->reg_bitmap_width;
  clear_bit (D.25642, D.25643, slot, callsite_index);
  D.25644 = gcfg->reg_pin_bitmap;
  D.25643 = gcfg->reg_bitmap_width;
  set_bit (D.25644, D.25643, slot, callsite_index);
  goto <D.25645>;
  <D.25641>:
  if (type == 1) goto <D.25646>; else goto <D.25647>;
  <D.25646>:
  D.25642 = gcfg->reg_ref_bitmap;
  D.25643 = gcfg->reg_bitmap_width;
  set_bit (D.25642, D.25643, slot, callsite_index);
  D.25644 = gcfg->reg_pin_bitmap;
  D.25643 = gcfg->reg_bitmap_width;
  clear_bit (D.25644, D.25643, slot, callsite_index);
  goto <D.25648>;
  <D.25647>:
  if (type == 0) goto <D.25649>; else goto <D.25650>;
  <D.25649>:
  D.25642 = gcfg->reg_ref_bitmap;
  D.25643 = gcfg->reg_bitmap_width;
  clear_bit (D.25642, D.25643, slot, callsite_index);
  D.25644 = gcfg->reg_pin_bitmap;
  D.25643 = gcfg->reg_bitmap_width;
  clear_bit (D.25644, D.25643, slot, callsite_index);
  <D.25650>:
  <D.25648>:
  <D.25645>:
}


set_bit (guint8 * bitmap, int width, int y, int x)
{
  int D.25651;
  int D.25652;
  int D.25653;
  sizetype D.25654;
  guint8 * D.25655;
  unsigned char D.25656;
  signed char D.25657;
  int D.25658;
  int D.25659;
  signed char D.25660;
  signed char D.25661;
  unsigned char D.25662;

  D.25651 = width * y;
  D.25652 = x / 8;
  D.25653 = D.25651 + D.25652;
  D.25654 = (sizetype) D.25653;
  D.25655 = bitmap + D.25654;
  D.25651 = width * y;
  D.25653 = D.25651 + D.25652;
  D.25654 = (sizetype) D.25653;
  D.25655 = bitmap + D.25654;
  D.25656 = *D.25655;
  D.25657 = (signed char) D.25656;
  D.25658 = x % 8;
  D.25659 = 1 << D.25658;
  D.25660 = (signed char) D.25659;
  D.25661 = D.25657 | D.25660;
  D.25662 = (unsigned char) D.25661;
  *D.25655 = D.25662;
}


clear_bit (guint8 * bitmap, int width, int y, int x)
{
  int D.25663;
  int D.25664;
  int D.25665;
  sizetype D.25666;
  guint8 * D.25667;
  unsigned char D.25668;
  signed char D.25669;
  int D.25670;
  int D.25671;
  signed char D.25672;
  signed char D.25673;
  signed char D.25674;
  unsigned char D.25675;

  D.25663 = width * y;
  D.25664 = x / 8;
  D.25665 = D.25663 + D.25664;
  D.25666 = (sizetype) D.25665;
  D.25667 = bitmap + D.25666;
  D.25663 = width * y;
  D.25665 = D.25663 + D.25664;
  D.25666 = (sizetype) D.25665;
  D.25667 = bitmap + D.25666;
  D.25668 = *D.25667;
  D.25669 = (signed char) D.25668;
  D.25670 = x % 8;
  D.25671 = 1 << D.25670;
  D.25672 = (signed char) D.25671;
  D.25673 = ~D.25672;
  D.25674 = D.25669 & D.25673;
  D.25675 = (unsigned char) D.25674;
  *D.25667 = D.25675;
}


process_spill_slots (struct MonoCompile * cfg)
{
  struct MonoSpillInfo * D.25676;
  unsigned int spill_slot.10;
  unsigned int D.25678;
  struct MonoSpillInfo * D.25679;
  unsigned int bank.11;
  unsigned int D.25681;
  struct MonoSpillInfo * D.25684;
  unsigned int spill_slot.12;
  unsigned int D.25686;
  struct MonoSpillInfo * D.25687;
  int D.25691;
  int D.25692;
  int D.25693;
  int D.25694;
  unsigned int D.25695;
  const char * D.25698;
  const char * iftmp.13;
  int D.25703;
  struct MonoSpillInfo * D.25704;
  unsigned int i.14;
  unsigned int D.25706;
  struct MonoSpillInfo * D.25707;
  const char * iftmp.15;
  int D.25716;
  int D.25717;
  struct MonoSpillInfo * D.25718;
  struct MonoSpillInfo * D.25719;
  const char * iftmp.16;
  int D.25728;
  int D.25729;
  struct MonoCompileGC * gcfg;
  struct MonoBasicBlock * bb;
  struct GSList * l;
  int i;

  gcfg = cfg->gc_info;
  bb = cfg->bb_entry;
  goto <D.25105>;
  <D.25104>:
  l = bb->spill_slot_defs;
  goto <D.25102>;
  <D.25101>:
  {
    struct MonoInst * def;
    int spill_slot;
    int bank;
    int offset;
    int slot;

    def = l->data;
    spill_slot = def->data.op[0].const_val;
    bank = def->data.op[1].const_val;
    D.25676 = cfg->spill_info[bank];
    spill_slot.10 = (unsigned int) spill_slot;
    D.25678 = spill_slot.10 * 4;
    D.25679 = D.25676 + D.25678;
    offset = D.25679->offset;
    slot = fp_offset_to_slot (cfg, offset);
    bank.11 = (unsigned int) bank;
    D.25681 = bank.11 + 4294967294;
    if (D.25681 <= 1) goto <D.25682>; else goto <D.25683>;
    <D.25682>:
    set_slot_everywhere (gcfg, slot, 0);
    <D.25683>:
  }
  l = l->next;
  <D.25102>:
  if (l != 0B) goto <D.25101>; else goto <D.25103>;
  <D.25103>:
  bb = bb->next_bb;
  <D.25105>:
  if (bb != 0B) goto <D.25104>; else goto <D.25106>;
  <D.25106>:
  bb = cfg->bb_entry;
  goto <D.25117>;
  <D.25116>:
  l = bb->spill_slot_defs;
  goto <D.25114>;
  <D.25113>:
  {
    struct MonoInst * def;
    int spill_slot;
    int bank;
    int offset;
    int slot;
    GCSlotType type;

    def = l->data;
    spill_slot = def->data.op[0].const_val;
    bank = def->data.op[1].const_val;
    D.25684 = cfg->spill_info[bank];
    spill_slot.12 = (unsigned int) spill_slot;
    D.25686 = spill_slot.12 * 4;
    D.25687 = D.25684 + D.25686;
    offset = D.25687->offset;
    slot = fp_offset_to_slot (cfg, offset);
    if (bank == 3) goto <D.25688>; else goto <D.25689>;
    <D.25688>:
    type = 2;
    goto <D.25690>;
    <D.25689>:
    type = 1;
    <D.25690>:
    D.25691 = def->backend.pc_offset;
    D.25692 = bb->native_offset;
    D.25693 = bb->native_length;
    D.25694 = D.25692 + D.25693;
    set_slot_in_range (gcfg, slot, D.25691, D.25694, type);
    D.25695 = cfg->verbose_level;
    if (D.25695 > 1) goto <D.25696>; else goto <D.25697>;
    <D.25696>:
    D.25698 = slot_type_to_string (type);
    if (offset >= 0) goto <D.25700>; else goto <D.25701>;
    <D.25700>:
    iftmp.13 = "";
    goto <D.25702>;
    <D.25701>:
    iftmp.13 = "-";
    <D.25702>:
    D.25703 = ABS_EXPR <offset>;
    printf ("\t%s spill slot at %s0x%x(fp) (slot = %d)\n", D.25698, iftmp.13, D.25703, slot);
    <D.25697>:
  }
  l = l->next;
  <D.25114>:
  if (l != 0B) goto <D.25113>; else goto <D.25115>;
  <D.25115>:
  bb = bb->next_bb;
  <D.25117>:
  if (bb != 0B) goto <D.25116>; else goto <D.25118>;
  <D.25118>:
  i = 0;
  goto <D.25123>;
  <D.25122>:
  {
    int offset;
    int slot;

    D.25704 = cfg->spill_info[1];
    i.14 = (unsigned int) i;
    D.25706 = i.14 * 4;
    D.25707 = D.25704 + D.25706;
    offset = D.25707->offset;
    if (offset == -1) goto <D.25708>; else goto <D.25709>;
    <D.25708>:
    // predicted unlikely by continue predictor.
    goto <D.25121>;
    <D.25709>:
    slot = fp_offset_to_slot (cfg, offset);
    set_slot_everywhere (gcfg, slot, 0);
    D.25695 = cfg->verbose_level;
    if (D.25695 > 1) goto <D.25710>; else goto <D.25711>;
    <D.25710>:
    if (offset >= 0) goto <D.25713>; else goto <D.25714>;
    <D.25713>:
    iftmp.15 = "";
    goto <D.25715>;
    <D.25714>:
    iftmp.15 = "-";
    <D.25715>:
    D.25716 = ABS_EXPR <offset>;
    printf ("\tfp spill slot at %s0x%x(fp) (slot = %d)\n", iftmp.15, D.25716, slot);
    <D.25711>:
  }
  <D.25121>:
  i = i + 1;
  <D.25123>:
  D.25717 = cfg->spill_info_len[1];
  if (D.25717 > i) goto <D.25122>; else goto <D.25124>;
  <D.25124>:
  i = 0;
  goto <D.25129>;
  <D.25128>:
  {
    int offset;
    int slot;

    D.25718 = cfg->spill_info[0];
    i.14 = (unsigned int) i;
    D.25706 = i.14 * 4;
    D.25719 = D.25718 + D.25706;
    offset = D.25719->offset;
    if (offset == -1) goto <D.25720>; else goto <D.25721>;
    <D.25720>:
    // predicted unlikely by continue predictor.
    goto <D.25127>;
    <D.25721>:
    slot = fp_offset_to_slot (cfg, offset);
    set_slot_everywhere (gcfg, slot, 0);
    D.25695 = cfg->verbose_level;
    if (D.25695 > 1) goto <D.25722>; else goto <D.25723>;
    <D.25722>:
    if (offset >= 0) goto <D.25725>; else goto <D.25726>;
    <D.25725>:
    iftmp.16 = "";
    goto <D.25727>;
    <D.25726>:
    iftmp.16 = "-";
    <D.25727>:
    D.25728 = ABS_EXPR <offset>;
    printf ("\tint spill slot at %s0x%x(fp) (slot = %d)\n", iftmp.16, D.25728, slot);
    <D.25723>:
  }
  <D.25127>:
  i = i + 1;
  <D.25129>:
  D.25729 = cfg->spill_info_len[0];
  if (D.25729 > i) goto <D.25128>; else goto <D.25130>;
  <D.25130>:
}


set_slot_in_range (struct MonoCompileGC * gcfg, int slot, int from, int to, GCSlotType type)
{
  struct GCCallSite * * D.25730;
  unsigned int cindex.17;
  unsigned int D.25732;
  struct GCCallSite * * D.25733;
  struct GCCallSite * D.25734;
  _Bool D.25735;
  _Bool D.25736;
  _Bool D.25737;
  int D.25740;
  int cindex;

  cindex = 0;
  goto <D.25060>;
  <D.25059>:
  {
    int callsite_offset;

    D.25730 = gcfg->callsites;
    cindex.17 = (unsigned int) cindex;
    D.25732 = cindex.17 * 4;
    D.25733 = D.25730 + D.25732;
    D.25734 = *D.25733;
    callsite_offset = D.25734->pc_offset;
    D.25735 = callsite_offset >= from;
    D.25736 = callsite_offset < to;
    D.25737 = D.25735 & D.25736;
    if (D.25737 != 0) goto <D.25738>; else goto <D.25739>;
    <D.25738>:
    set_slot (gcfg, slot, cindex, type);
    <D.25739>:
  }
  cindex = cindex + 1;
  <D.25060>:
  D.25740 = gcfg->ncallsites;
  if (D.25740 > cindex) goto <D.25059>; else goto <D.25061>;
  <D.25061>:
}


set_slot (struct MonoCompileGC * gcfg, int slot, int callsite_index, GCSlotType type)
{
  int iftmp.18;
  int D.25746;
  _Bool D.25747;
  long int D.25748;
  long int D.25749;
  guint8 * D.25754;
  int D.25755;
  guint8 * D.25756;

  if (slot < 0) goto <D.25742>; else goto <D.25745>;
  <D.25745>:
  D.25746 = gcfg->nslots;
  if (D.25746 <= slot) goto <D.25742>; else goto <D.25743>;
  <D.25742>:
  iftmp.18 = 1;
  goto <D.25744>;
  <D.25743>:
  iftmp.18 = 0;
  <D.25744>:
  D.25747 = iftmp.18 != 0;
  D.25748 = (long int) D.25747;
  D.25749 = __builtin_expect (D.25748, 0);
  if (D.25749 != 0) goto <D.25750>; else goto <D.25751>;
  <D.25750>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 1327, "slot >= 0 && slot < gcfg->nslots");
  <D.25751>:
  if (type == 2) goto <D.25752>; else goto <D.25753>;
  <D.25752>:
  D.25754 = gcfg->stack_ref_bitmap;
  D.25755 = gcfg->stack_bitmap_width;
  clear_bit (D.25754, D.25755, slot, callsite_index);
  D.25756 = gcfg->stack_pin_bitmap;
  D.25755 = gcfg->stack_bitmap_width;
  set_bit (D.25756, D.25755, slot, callsite_index);
  goto <D.25757>;
  <D.25753>:
  if (type == 1) goto <D.25758>; else goto <D.25759>;
  <D.25758>:
  D.25754 = gcfg->stack_ref_bitmap;
  D.25755 = gcfg->stack_bitmap_width;
  set_bit (D.25754, D.25755, slot, callsite_index);
  D.25756 = gcfg->stack_pin_bitmap;
  D.25755 = gcfg->stack_bitmap_width;
  clear_bit (D.25756, D.25755, slot, callsite_index);
  goto <D.25760>;
  <D.25759>:
  if (type == 0) goto <D.25761>; else goto <D.25762>;
  <D.25761>:
  D.25754 = gcfg->stack_ref_bitmap;
  D.25755 = gcfg->stack_bitmap_width;
  clear_bit (D.25754, D.25755, slot, callsite_index);
  D.25756 = gcfg->stack_pin_bitmap;
  D.25755 = gcfg->stack_bitmap_width;
  clear_bit (D.25756, D.25755, slot, callsite_index);
  <D.25762>:
  <D.25760>:
  <D.25757>:
}


slot_type_to_string (GCSlotType type)
{
  const char * D.25763;

  switch (type) <default: <D.24885>, case 0: <D.24883>, case 1: <D.24882>, case 2: <D.24884>>
  <D.24882>:
  D.25763 = "ref";
  return D.25763;
  <D.24883>:
  D.25763 = "noref";
  return D.25763;
  <D.24884>:
  D.25763 = "pin";
  return D.25763;
  <D.24885>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-gc.c", 663);
  D.25763 = 0B;
  return D.25763;
}


fp_offset_to_slot (struct MonoCompile * cfg, int offset)
{
  int D.25765;
  int D.25766;
  int D.25767;
  struct MonoCompileGC * gcfg;

  gcfg = cfg->gc_info;
  D.25766 = gcfg->min_offset;
  D.25767 = offset - D.25766;
  D.25765 = D.25767 / 4;
  return D.25765;
}


set_slot_everywhere (struct MonoCompileGC * gcfg, int slot, GCSlotType type)
{
  sizetype pos.19;
  void * D.25772;
  unsigned int width.20;
  void * D.25774;
  int width;
  int pos;
  guint8 * ref_bitmap;
  guint8 * pin_bitmap;

  ref_bitmap = gcfg->stack_ref_bitmap;
  pin_bitmap = gcfg->stack_pin_bitmap;
  width = gcfg->stack_bitmap_width;
  pos = width * slot;
  if (type == 2) goto <D.25769>; else goto <D.25770>;
  <D.25769>:
  pos.19 = (sizetype) pos;
  D.25772 = ref_bitmap + pos.19;
  width.20 = (unsigned int) width;
  memset (D.25772, 0, width.20);
  pos.19 = (sizetype) pos;
  D.25774 = pin_bitmap + pos.19;
  width.20 = (unsigned int) width;
  memset (D.25774, 255, width.20);
  goto <D.25775>;
  <D.25770>:
  if (type == 1) goto <D.25776>; else goto <D.25777>;
  <D.25776>:
  pos.19 = (sizetype) pos;
  D.25772 = ref_bitmap + pos.19;
  width.20 = (unsigned int) width;
  memset (D.25772, 255, width.20);
  pos.19 = (sizetype) pos;
  D.25774 = pin_bitmap + pos.19;
  width.20 = (unsigned int) width;
  memset (D.25774, 0, width.20);
  goto <D.25778>;
  <D.25777>:
  if (type == 0) goto <D.25779>; else goto <D.25780>;
  <D.25779>:
  pos.19 = (sizetype) pos;
  D.25772 = ref_bitmap + pos.19;
  width.20 = (unsigned int) width;
  memset (D.25772, 0, width.20);
  pos.19 = (sizetype) pos;
  D.25774 = pin_bitmap + pos.19;
  width.20 = (unsigned int) width;
  memset (D.25774, 0, width.20);
  <D.25780>:
  <D.25778>:
  <D.25775>:
}


process_other_slots (struct MonoCompile * cfg)
{
  void * D.25781;
  unsigned int D.25782;
  int D.25783;
  int D.25784;
  int D.25785;
  int D.25786;
  int D.25787;
  unsigned int D.25788;
  const char * iftmp.21;
  int D.25797;
  int D.25798;
  int D.25799;
  struct MonoCompileGC * gcfg;
  struct GSList * l;

  gcfg = cfg->gc_info;
  l = gcfg->stack_slots_from_cfa;
  goto <D.25142>;
  <D.25141>:
  {
    guint data;
    int cfa_slot;
    GCSlotType type;
    int slot;

    D.25781 = l->data;
    data = (guint) D.25781;
    D.25782 = data >> 16;
    cfa_slot = (int) D.25782;
    type = data & 255;
    D.25783 = cfg->cfa_offset;
    D.25784 = D.25783 / 4;
    D.25785 = D.25784 - cfa_slot;
    D.25786 = gcfg->min_offset;
    D.25787 = D.25786 / -4;
    slot = D.25785 + D.25787;
    set_slot_everywhere (gcfg, slot, type);
    D.25788 = cfg->verbose_level;
    if (D.25788 > 1) goto <D.25789>; else goto <D.25790>;
    <D.25789>:
    {
      int fp_offset;

      fp_offset = slot_to_fp_offset (cfg, slot);
      if (type == 0) goto <D.25791>; else goto <D.25792>;
      <D.25791>:
      if (fp_offset >= 0) goto <D.25794>; else goto <D.25795>;
      <D.25794>:
      iftmp.21 = "";
      goto <D.25796>;
      <D.25795>:
      iftmp.21 = "-";
      <D.25796>:
      D.25797 = ABS_EXPR <fp_offset>;
      D.25798 = cfa_slot * 4;
      printf ("\tnoref slot at %s0x%x(fp) (slot = %d) (cfa - 0x%x)\n", iftmp.21, D.25797, slot, D.25798);
      <D.25792>:
    }
    <D.25790>:
  }
  l = l->next;
  <D.25142>:
  if (l != 0B) goto <D.25141>; else goto <D.25143>;
  <D.25143>:
  l = gcfg->stack_slots_from_fp;
  goto <D.25149>;
  <D.25148>:
  {
    gint data;
    int offset;
    GCSlotType type;
    int slot;

    D.25781 = l->data;
    data = (gint) D.25781;
    offset = data >> 16;
    D.25799 = data & 255;
    type = (GCSlotType) D.25799;
    slot = fp_offset_to_slot (cfg, offset);
    set_slot_everywhere (gcfg, slot, type);
    D.25788 = cfg->verbose_level;
    if (D.25788 > 1) goto <D.25800>; else goto <D.25801>;
    <D.25800>:
    if (type == 1) goto <D.25802>; else goto <D.25803>;
    <D.25802>:
    printf ("\tref slot at fp+0x%x (slot = %d)\n", offset, slot);
    goto <D.25804>;
    <D.25803>:
    if (type == 0) goto <D.25805>; else goto <D.25806>;
    <D.25805>:
    printf ("\tnoref slot at 0x%x(fp) (slot = %d)\n", offset, slot);
    <D.25806>:
    <D.25804>:
    <D.25801>:
  }
  l = l->next;
  <D.25149>:
  if (l != 0B) goto <D.25148>; else goto <D.25150>;
  <D.25150>:
}


slot_to_fp_offset (struct MonoCompile * cfg, int slot)
{
  int D.25807;
  int D.25808;
  int D.25809;
  struct MonoCompileGC * gcfg;

  gcfg = cfg->gc_info;
  D.25808 = slot * 4;
  D.25809 = gcfg->min_offset;
  D.25807 = D.25808 + D.25809;
  return D.25807;
}


process_param_area_slots (struct MonoCompile * cfg)
{
  unsigned int D.25811;
  unsigned int D.25812;
  struct MonoMemPool * D.25815;
  int D.25816;
  unsigned int D.25817;
  unsigned int D.25818;
  struct GCCallSite * * D.25819;
  unsigned int cindex.22;
  unsigned int D.25821;
  struct GCCallSite * * D.25822;
  int D.25823;
  struct MonoGenericSharingContext * D.25826;
  int D.25827;
  int iftmp.23;
  int D.25833;
  _Bool D.25835;
  long int D.25836;
  long int D.25837;
  unsigned int D.25840;
  unsigned int D.25841;
  gboolean * D.25842;
  unsigned int i.24;
  unsigned int D.25844;
  int D.25845;
  unsigned int i.25;
  unsigned int D.25847;
  gboolean * D.25848;
  int D.25849;
  struct MonoCompileGC * gcfg;
  int cindex;
  int i;
  gboolean * is_param;

  gcfg = cfg->gc_info;
  D.25811 = cfg->flags;
  D.25812 = D.25811 & 1;
  if (D.25812 != 0) goto <D.25813>; else goto <D.25814>;
  <D.25813>:
  return;
  <D.25814>:
  D.25815 = cfg->mempool;
  D.25816 = gcfg->nslots;
  D.25817 = (unsigned int) D.25816;
  D.25818 = D.25817 * 4;
  is_param = mono_mempool_alloc0 (D.25815, D.25818);
  cindex = 0;
  goto <D.25253>;
  <D.25252>:
  {
    struct GCCallSite * callsite;
    struct GSList * l;

    D.25819 = gcfg->callsites;
    cindex.22 = (unsigned int) cindex;
    D.25821 = cindex.22 * 4;
    D.25822 = D.25819 + D.25821;
    callsite = *D.25822;
    l = callsite->param_slots;
    goto <D.25250>;
    <D.25249>:
    {
      struct MonoInst * def;
      struct MonoType * t;
      int sp_offset;
      int fp_offset;
      int slot;
      guint32 align;
      guint32 size;

      try
        {
          def = l->data;
          t = def->data.op[1].vtype;
          sp_offset = def->data.op[0].const_val;
          fp_offset = sp_offset_to_fp_offset (cfg, sp_offset);
          slot = fp_offset_to_slot (cfg, fp_offset);
          D.25823 = mono_type_is_struct (t);
          if (D.25823 != 0) goto <D.25824>; else goto <D.25825>;
          <D.25824>:
          D.25826 = cfg->generic_sharing_context;
          D.25827 = mini_type_stack_size_full (D.25826, t, &align, 0);
          size = (guint32) D.25827;
          goto <D.25828>;
          <D.25825>:
          size = 4;
          <D.25828>:
          i = 0;
          goto <D.25247>;
          <D.25246>:
          D.25833 = slot + i;
          if (D.25833 < 0) goto <D.25830>; else goto <D.25834>;
          <D.25834>:
          D.25833 = slot + i;
          D.25816 = gcfg->nslots;
          if (D.25833 >= D.25816) goto <D.25830>; else goto <D.25831>;
          <D.25830>:
          iftmp.23 = 1;
          goto <D.25832>;
          <D.25831>:
          iftmp.23 = 0;
          <D.25832>:
          D.25835 = iftmp.23 != 0;
          D.25836 = (long int) D.25835;
          D.25837 = __builtin_expect (D.25836, 0);
          if (D.25837 != 0) goto <D.25838>; else goto <D.25839>;
          <D.25838>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 1913, "slot + i >= 0 && slot + i < gcfg->nslots");
          <D.25839>:
          D.25833 = slot + i;
          D.25840 = (unsigned int) D.25833;
          D.25841 = D.25840 * 4;
          D.25842 = is_param + D.25841;
          *D.25842 = 1;
          i = i + 1;
          <D.25247>:
          i.24 = (unsigned int) i;
          D.25844 = size / 4;
          if (i.24 < D.25844) goto <D.25246>; else goto <D.25248>;
          <D.25248>:
        }
      finally
        {
          align = {CLOBBER};
        }
    }
    l = l->next;
    <D.25250>:
    if (l != 0B) goto <D.25249>; else goto <D.25251>;
    <D.25251>:
  }
  cindex = cindex + 1;
  <D.25253>:
  D.25845 = gcfg->ncallsites;
  if (D.25845 > cindex) goto <D.25252>; else goto <D.25254>;
  <D.25254>:
  i = 0;
  goto <D.25256>;
  <D.25255>:
  i.25 = (unsigned int) i;
  D.25847 = i.25 * 4;
  D.25848 = is_param + D.25847;
  D.25849 = *D.25848;
  if (D.25849 != 0) goto <D.25850>; else goto <D.25851>;
  <D.25850>:
  set_slot_everywhere (gcfg, i, 0);
  <D.25851>:
  i = i + 1;
  <D.25256>:
  D.25816 = gcfg->nslots;
  if (D.25816 > i) goto <D.25255>; else goto <D.25257>;
  <D.25257>:
}


sp_offset_to_fp_offset (struct MonoCompile * cfg, int sp_offset)
{
  int D.25853;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-gc.c", 1871);
  D.25853 = -1;
  return D.25853;
}


process_variables (struct MonoCompile * cfg)
{
  struct MonoMethod * D.25855;
  int D.25856;
  int D.25857;
  int D.25858;
  unsigned int D.25859;
  unsigned int D.25860;
  struct MonoBasicBlock * D.25861;
  short unsigned int D.25862;
  unsigned int vreg.26;
  unsigned int D.25866;
  int * D.25867;
  int D.25868;
  int D.25871;
  _Bool D.25872;
  long int D.25873;
  long int D.25874;
  struct MonoInst * * D.25877;
  unsigned int i.27;
  unsigned int D.25879;
  struct MonoInst * * D.25880;
  unsigned int i.28;
  unsigned int D.25882;
  _Bool D.25883;
  struct MonoInst * D.25884;
  short unsigned int D.25889;
  int D.25891;
  struct MonoMethodVar * D.25892;
  unsigned int D.25893;
  unsigned char D.25894;
  unsigned char D.25895;
  struct MonoInst * * D.25898;
  struct MonoInst * D.25899;
  struct MonoClass * D.25902;
  unsigned char D.25903;
  unsigned char D.25904;
  <unnamed-unsigned:1> D.25907;
  _Bool D.25910;
  long int D.25911;
  long int D.25912;
  int D.25918;
  _Bool D.25919;
  struct GCCallSite * * D.25923;
  unsigned int cindex.29;
  unsigned int D.25925;
  struct GCCallSite * * D.25926;
  struct GCCallSite * D.25927;
  guint8 * D.25928;
  int D.25929;
  sizetype D.25930;
  guint8 * D.25931;
  unsigned char D.25932;
  int D.25933;
  int D.25934;
  int D.25935;
  int D.25936;
  int D.25939;
  unsigned int D.25940;
  const char * D.25943;
  const char * iftmp.30;
  const char * D.25948;
  int D.25949;
  int D.25952;
  unsigned int D.25953;
  unsigned int D.25954;
  int D.25957;
  unsigned char D.25960;
  int D.25961;
  int D.25962;
  int pos.31;
  const char * D.25968;
  int D.25969;
  struct MonoType * D.25970;
  char * D.25971;
  int D.25972;
  int D.25975;
  struct MonoClass * D.25978;
  int D.25980;
  const char * D.25983;
  int D.25984;
  const char * D.25985;
  int D.25986;
  int D.25987;
  int D.25988;
  unsigned int size_in_slots.32;
  unsigned int D.25990;
  char * D.25991;
  unsigned char D.25992;
  unsigned char D.25993;
  unsigned int j.33;
  unsigned int D.25999;
  int D.26000;
  unsigned int D.26005;
  unsigned int D.26006;
  int * D.26007;
  int D.26008;
  int D.26015;
  unsigned int j.34;
  unsigned int D.26019;
  unsigned int D.26020;
  gsize * D.26021;
  unsigned int D.26022;
  int D.26023;
  unsigned int D.26024;
  unsigned int D.26025;
  unsigned int D.26028;
  int D.26029;
  GCSlotType iftmp.35;
  int numbits.36;
  const char * iftmp.37;
  int D.26043;
  int D.26044;
  int D.26053;
  unsigned char D.26054;
  unsigned char D.26055;
  const char * iftmp.38;
  int D.26069;
  char * D.26070;
  int D.26071;
  const char * iftmp.39;
  const char * iftmp.40;
  char * D.26084;
  unsigned char D.26087;
  unsigned char D.26088;
  _Bool D.26089;
  _Bool D.26090;
  _Bool D.26091;
  unsigned int D.26094;
  int D.26095;
  const char * iftmp.41;
  int iftmp.42;
  char * D.26106;
  int D.26107;
  unsigned int D.26117;
  int D.26118;
  const char * iftmp.43;
  char * D.26126;
  const char * iftmp.44;
  const char * iftmp.45;
  char * D.26142;
  unsigned int D.26143;
  struct MonoCompileGC * gcfg;
  struct MonoMethodSignature * sig;
  int i;
  int locals_min_slot;
  int locals_max_slot;
  int cindex;
  struct MonoBasicBlock * bb;
  struct MonoInst * tmp;
  int * pc_offsets;
  int locals_min_offset;
  int locals_max_offset;

  gcfg = cfg->gc_info;
  D.25855 = cfg->method;
  sig = mono_method_signature (D.25855);
  locals_min_offset = gcfg->locals_min_offset;
  locals_max_offset = gcfg->locals_max_offset;
  D.25856 = gcfg->min_offset;
  D.25857 = locals_min_offset - D.25856;
  locals_min_slot = D.25857 / 4;
  D.25856 = gcfg->min_offset;
  D.25858 = locals_max_offset - D.25856;
  locals_max_slot = D.25858 / 4;
  i = locals_min_slot;
  goto <D.25177>;
  <D.25176>:
  set_slot_everywhere (gcfg, i, 0);
  i = i + 1;
  <D.25177>:
  if (i < locals_max_slot) goto <D.25176>; else goto <D.25178>;
  <D.25178>:
  D.25859 = cfg->next_vreg;
  D.25860 = D.25859 * 4;
  pc_offsets = monoeg_malloc0 (D.25860);
  D.25861 = cfg->bb_entry;
  bb = D.25861->next_bb;
  tmp = bb->code;
  goto <D.25181>;
  <D.25180>:
  D.25862 = tmp->opcode;
  if (D.25862 == 838) goto <D.25863>; else goto <D.25864>;
  <D.25863>:
  {
    int vreg;

    vreg = tmp->data.op[1].const_val;
    vreg.26 = (unsigned int) vreg;
    D.25866 = vreg.26 * 4;
    D.25867 = pc_offsets + D.25866;
    D.25868 = *D.25867;
    if (D.25868 == 0) goto <D.25869>; else goto <D.25870>;
    <D.25869>:
    D.25871 = tmp->backend.pc_offset;
    D.25872 = D.25871 <= 0;
    D.25873 = (long int) D.25872;
    D.25874 = __builtin_expect (D.25873, 0);
    if (D.25874 != 0) goto <D.25875>; else goto <D.25876>;
    <D.25875>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 1613, "tmp->backend.pc_offset > 0");
    <D.25876>:
    vreg.26 = (unsigned int) vreg;
    D.25866 = vreg.26 * 4;
    D.25867 = pc_offsets + D.25866;
    D.25871 = tmp->backend.pc_offset;
    *D.25867 = D.25871;
    <D.25870>:
  }
  <D.25864>:
  tmp = tmp->next;
  <D.25181>:
  if (tmp != 0B) goto <D.25180>; else goto <D.25182>;
  <D.25182>:
  i = 0;
  goto <D.25224>;
  <D.25223>:
  {
    struct MonoInst * ins;
    struct MonoType * t;
    struct MonoMethodVar * vmv;
    guint32 pos;
    gboolean byref;
    gboolean is_this;
    gboolean is_arg;

    D.25877 = cfg->varinfo;
    i.27 = (unsigned int) i;
    D.25879 = i.27 * 4;
    D.25880 = D.25877 + D.25879;
    ins = *D.25880;
    t = ins->data.op[1].vtype;
    is_this = 0;
    i.28 = (unsigned int) i;
    D.25882 = cfg->locals_start;
    D.25883 = i.28 < D.25882;
    is_arg = (gboolean) D.25883;
    D.25884 = cfg->ret;
    if (D.25884 == ins) goto <D.25885>; else goto <D.25886>;
    <D.25885>:
    D.25889 = ins->opcode;
    if (D.25889 != 367) goto <D.25887>; else goto <D.25890>;
    <D.25890>:
    D.25891 = mono_type_is_struct (t);
    if (D.25891 == 0) goto <D.25887>; else goto <D.25888>;
    <D.25887>:
    // predicted unlikely by continue predictor.
    goto <D.25190>;
    <D.25888>:
    <D.25886>:
    D.25892 = cfg->vars;
    i.27 = (unsigned int) i;
    D.25893 = i.27 * 56;
    vmv = D.25892 + D.25893;
    D.25894 = BIT_FIELD_REF <*sig, 8, 80>;
    D.25895 = D.25894 & 64;
    if (D.25895 != 0) goto <D.25896>; else goto <D.25897>;
    <D.25896>:
    D.25898 = cfg->args;
    D.25899 = *D.25898;
    if (D.25899 == ins) goto <D.25900>; else goto <D.25901>;
    <D.25900>:
    D.25855 = cfg->method;
    D.25902 = D.25855->klass;
    D.25903 = BIT_FIELD_REF <*D.25902, 8, 160>;
    D.25904 = D.25903 & 8;
    if (D.25904 == 0) goto <D.25905>; else goto <D.25906>;
    <D.25905>:
    D.25855 = cfg->method;
    D.25902 = D.25855->klass;
    t = &D.25902->byval_arg;
    is_this = 1;
    <D.25906>:
    <D.25901>:
    <D.25897>:
    D.25907 = t->byref;
    byref = (gboolean) D.25907;
    D.25889 = ins->opcode;
    if (D.25889 == 366) goto <D.25908>; else goto <D.25909>;
    <D.25908>:
    {
      int hreg;
      GCSlotType slot_type;

      t = mini_type_get_underlying_type (0B, t);
      hreg = ins->dreg;
      D.25910 = hreg > 15;
      D.25911 = (long int) D.25910;
      D.25912 = __builtin_expect (D.25911, 0);
      if (D.25912 != 0) goto <D.25913>; else goto <D.25914>;
      <D.25913>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 1653, "hreg < MONO_MAX_IREGS");
      <D.25914>:
      if (byref != 0) goto <D.25915>; else goto <D.25916>;
      <D.25915>:
      slot_type = 2;
      goto <D.25917>;
      <D.25916>:
      D.25918 = mini_type_is_reference (cfg, t);
      D.25919 = D.25918 != 0;
      slot_type = (GCSlotType) D.25919;
      <D.25917>:
      if (slot_type == 2) goto <D.25920>; else goto <D.25921>;
      <D.25920>:
      set_reg_slot_everywhere (gcfg, hreg, slot_type);
      goto <D.25922>;
      <D.25921>:
      cindex = 0;
      goto <D.25194>;
      <D.25193>:
      D.25923 = gcfg->callsites;
      cindex.29 = (unsigned int) cindex;
      D.25925 = cindex.29 * 4;
      D.25926 = D.25923 + D.25925;
      D.25927 = *D.25926;
      D.25928 = D.25927->liveness;
      D.25929 = i / 8;
      D.25930 = (sizetype) D.25929;
      D.25931 = D.25928 + D.25930;
      D.25932 = *D.25931;
      D.25933 = (int) D.25932;
      D.25934 = i % 8;
      D.25935 = D.25933 >> D.25934;
      D.25936 = D.25935 & 1;
      if (D.25936 != 0) goto <D.25937>; else goto <D.25938>;
      <D.25937>:
      set_reg_slot (gcfg, hreg, cindex, slot_type);
      <D.25938>:
      cindex = cindex + 1;
      <D.25194>:
      D.25939 = gcfg->ncallsites;
      if (D.25939 > cindex) goto <D.25193>; else goto <D.25195>;
      <D.25195>:
      <D.25922>:
      D.25940 = cfg->verbose_level;
      if (D.25940 > 1) goto <D.25941>; else goto <D.25942>;
      <D.25941>:
      D.25943 = slot_type_to_string (slot_type);
      if (is_arg != 0) goto <D.25945>; else goto <D.25946>;
      <D.25945>:
      iftmp.30 = "arg ";
      goto <D.25947>;
      <D.25946>:
      iftmp.30 = "";
      <D.25947>:
      D.25948 = mono_arch_regname (hreg);
      D.25949 = vmv->vreg;
      printf ("\t%s %sreg %s(R%d)\n", D.25943, iftmp.30, D.25948, D.25949);
      <D.25942>:
      // predicted unlikely by continue predictor.
      goto <D.25190>;
    }
    <D.25909>:
    D.25889 = ins->opcode;
    if (D.25889 != 367) goto <D.25950>; else goto <D.25951>;
    <D.25950>:
    // predicted unlikely by continue predictor.
    goto <D.25190>;
    <D.25951>:
    D.25952 = ins->data.op[0].const_val;
    D.25953 = (unsigned int) D.25952;
    D.25954 = D.25953 & 3;
    if (D.25954 != 0) goto <D.25955>; else goto <D.25956>;
    <D.25955>:
    // predicted unlikely by continue predictor.
    goto <D.25190>;
    <D.25956>:
    D.25952 = ins->data.op[0].const_val;
    D.25957 = fp_offset_to_slot (cfg, D.25952);
    pos = (guint32) D.25957;
    if (is_arg != 0) goto <D.25958>; else goto <D.25959>;
    <D.25958>:
    D.25960 = ins->flags;
    D.25961 = (int) D.25960;
    D.25962 = D.25961 & 2;
    if (D.25962 != 0) goto <D.25963>; else goto <D.25964>;
    <D.25963>:
    pos.31 = (int) pos;
    set_slot_everywhere (gcfg, pos.31, 0);
    D.25940 = cfg->verbose_level;
    if (D.25940 > 1) goto <D.25966>; else goto <D.25967>;
    <D.25966>:
    D.25952 = ins->data.op[0].const_val;
    D.25968 = get_offset_sign (D.25952);
    D.25952 = ins->data.op[0].const_val;
    D.25969 = get_offset_val (D.25952);
    D.25970 = ins->data.op[1].vtype;
    D.25971 = mono_type_full_name (D.25970);
    printf ("\tdead arg at fp%s0x%x (slot = %d): %s\n", D.25968, D.25969, pos, D.25971);
    <D.25967>:
    // predicted unlikely by continue predictor.
    goto <D.25190>;
    <D.25964>:
    <D.25959>:
    D.25972 = mono_type_is_struct (t);
    if (D.25972 != 0) goto <D.25973>; else goto <D.25974>;
    <D.25973>:
    {
      int numbits;
      int j;
      gsize * bitmap;
      gboolean pin;
      int size;
      int size_in_slots;

      try
        {
          numbits = 0;
          bitmap = 0B;
          pin = 0;
          D.25975 = ins->backend.is_pinvoke;
          if (D.25975 != 0) goto <D.25976>; else goto <D.25977>;
          <D.25976>:
          D.25978 = ins->klass;
          size = mono_class_native_size (D.25978, 0B);
          goto <D.25979>;
          <D.25977>:
          D.25978 = ins->klass;
          size = mono_class_value_size (D.25978, 0B);
          <D.25979>:
          D.25980 = size + 3;
          size_in_slots = D.25980 >> 2;
          D.25940 = cfg->verbose_level;
          if (D.25940 > 1) goto <D.25981>; else goto <D.25982>;
          <D.25981>:
          D.25949 = vmv->vreg;
          D.25952 = ins->data.op[0].const_val;
          D.25983 = get_offset_sign (D.25952);
          D.25952 = ins->data.op[0].const_val;
          D.25984 = get_offset_val (D.25952);
          D.25952 = ins->data.op[0].const_val;
          D.25985 = get_offset_sign (D.25952);
          D.25952 = ins->data.op[0].const_val;
          D.25986 = size_in_slots * 4;
          D.25987 = D.25952 + D.25986;
          D.25988 = get_offset_val (D.25987);
          size_in_slots.32 = (unsigned int) size_in_slots;
          D.25990 = pos + size_in_slots.32;
          D.25970 = ins->data.op[1].vtype;
          D.25991 = mono_type_full_name (D.25970);
          printf ("\tvtype R%d at %s0x%x(fp)-%s0x%x(fp) (slot %d-%d): %s\n", D.25949, D.25983, D.25984, D.25985, D.25988, pos, D.25990, D.25991);
          <D.25982>:
          D.25978 = ins->klass;
          D.25992 = BIT_FIELD_REF <*D.25978, 8, 184>;
          D.25993 = D.25992 & 8;
          if (D.25993 == 0) goto <D.25994>; else goto <D.25995>;
          <D.25994>:
          if (is_arg != 0) goto <D.25996>; else goto <D.25997>;
          <D.25996>:
          j = 0;
          goto <D.25203>;
          <D.25202>:
          j.33 = (unsigned int) j;
          D.25999 = pos + j.33;
          D.26000 = (int) D.25999;
          set_slot_everywhere (gcfg, D.26000, 0);
          j = j + 1;
          <D.25203>:
          if (j < size_in_slots) goto <D.25202>; else goto <D.25204>;
          <D.25204>:
          <D.25997>:
          // predicted unlikely by continue predictor.
          goto <D.25190>;
          <D.25995>:
          bitmap = get_vtype_bitmap (t, &numbits);
          if (bitmap == 0B) goto <D.26001>; else goto <D.26002>;
          <D.26001>:
          pin = 1;
          <D.26002>:
          if (is_arg == 0) goto <D.26003>; else goto <D.26004>;
          <D.26003>:
          D.25949 = vmv->vreg;
          D.26005 = (unsigned int) D.25949;
          D.26006 = D.26005 * 4;
          D.26007 = pc_offsets + D.26006;
          D.26008 = *D.26007;
          if (D.26008 == 0) goto <D.26009>; else goto <D.26010>;
          <D.26009>:
          pin = 1;
          <D.26010>:
          D.25975 = ins->backend.is_pinvoke;
          if (D.25975 != 0) goto <D.26011>; else goto <D.26012>;
          <D.26011>:
          pin = 1;
          <D.26012>:
          <D.26004>:
          if (bitmap != 0B) goto <D.26013>; else goto <D.26014>;
          <D.26013>:
          cindex = 0;
          goto <D.25209>;
          <D.25208>:
          D.25923 = gcfg->callsites;
          cindex.29 = (unsigned int) cindex;
          D.25925 = cindex.29 * 4;
          D.25926 = D.25923 + D.25925;
          D.25927 = *D.25926;
          D.26015 = D.25927->pc_offset;
          D.25949 = vmv->vreg;
          D.26005 = (unsigned int) D.25949;
          D.26006 = D.26005 * 4;
          D.26007 = pc_offsets + D.26006;
          D.26008 = *D.26007;
          if (D.26015 > D.26008) goto <D.26016>; else goto <D.26017>;
          <D.26016>:
          j = 0;
          goto <D.25206>;
          <D.25205>:
          j.34 = (unsigned int) j;
          D.26019 = j.34 / 32;
          D.26020 = D.26019 * 4;
          D.26021 = bitmap + D.26020;
          D.26022 = *D.26021;
          D.26023 = j & 31;
          D.26024 = 1 << D.26023;
          D.26025 = D.26022 & D.26024;
          if (D.26025 != 0) goto <D.26026>; else goto <D.26027>;
          <D.26026>:
          j.33 = (unsigned int) j;
          D.25999 = pos + j.33;
          D.26028 = D.25999 + 4294967294;
          D.26029 = (int) D.26028;
          if (pin != 0) goto <D.26031>; else goto <D.26032>;
          <D.26031>:
          iftmp.35 = 2;
          goto <D.26033>;
          <D.26032>:
          iftmp.35 = 1;
          <D.26033>:
          set_slot (gcfg, D.26029, cindex, iftmp.35);
          <D.26027>:
          j = j + 1;
          <D.25206>:
          numbits.36 = numbits;
          if (j < numbits.36) goto <D.25205>; else goto <D.25207>;
          <D.25207>:
          <D.26017>:
          cindex = cindex + 1;
          <D.25209>:
          D.25939 = gcfg->ncallsites;
          if (D.25939 > cindex) goto <D.25208>; else goto <D.25210>;
          <D.25210>:
          D.25940 = cfg->verbose_level;
          if (D.25940 > 1) goto <D.26035>; else goto <D.26036>;
          <D.26035>:
          j = 0;
          goto <D.25212>;
          <D.25211>:
          j.34 = (unsigned int) j;
          D.26019 = j.34 / 32;
          D.26020 = D.26019 * 4;
          D.26021 = bitmap + D.26020;
          D.26022 = *D.26021;
          D.26023 = j & 31;
          D.26024 = 1 << D.26023;
          D.26025 = D.26022 & D.26024;
          if (D.26025 != 0) goto <D.26037>; else goto <D.26038>;
          <D.26037>:
          if (pin != 0) goto <D.26040>; else goto <D.26041>;
          <D.26040>:
          iftmp.37 = "pin";
          goto <D.26042>;
          <D.26041>:
          iftmp.37 = "ref";
          <D.26042>:
          D.25952 = ins->data.op[0].const_val;
          D.26043 = j * 4;
          D.26044 = D.25952 + D.26043;
          j.33 = (unsigned int) j;
          D.25999 = pos + j.33;
          D.26028 = D.25999 + 4294967294;
          D.26029 = (int) D.26028;
          printf ("\t\t%s slot at 0x%x(fp) (slot = %d)\n", iftmp.37, D.26044, D.26029);
          <D.26038>:
          j = j + 1;
          <D.25212>:
          numbits.36 = numbits;
          if (j < numbits.36) goto <D.25211>; else goto <D.25213>;
          <D.25213>:
          <D.26036>:
          goto <D.26045>;
          <D.26014>:
          D.25940 = cfg->verbose_level;
          if (D.25940 > 1) goto <D.26046>; else goto <D.26047>;
          <D.26046>:
          printf ("\t\tpinned\n");
          <D.26047>:
          j = 0;
          goto <D.25215>;
          <D.25214>:
          j.33 = (unsigned int) j;
          D.25999 = pos + j.33;
          D.26000 = (int) D.25999;
          set_slot_everywhere (gcfg, D.26000, 2);
          j = j + 1;
          <D.25215>:
          if (j < size_in_slots) goto <D.25214>; else goto <D.25216>;
          <D.25216>:
          <D.26045>:
          monoeg_g_free (bitmap);
          // predicted unlikely by continue predictor.
          goto <D.25190>;
        }
      finally
        {
          numbits = {CLOBBER};
        }
    }
    <D.25974>:
    if (is_arg == 0) goto <D.26050>; else goto <D.26051>;
    <D.26050>:
    D.25952 = ins->data.op[0].const_val;
    D.25856 = gcfg->min_offset;
    if (D.25952 < D.25856) goto <D.26048>; else goto <D.26052>;
    <D.26052>:
    D.25952 = ins->data.op[0].const_val;
    D.26053 = gcfg->max_offset;
    if (D.25952 >= D.26053) goto <D.26048>; else goto <D.26049>;
    <D.26048>:
    // predicted unlikely by continue predictor.
    goto <D.25190>;
    <D.26049>:
    <D.26051>:
    D.26054 = BIT_FIELD_REF <*t, 8, 56>;
    D.26055 = D.26054 & 64;
    if (D.26055 != 0) goto <D.26056>; else goto <D.26057>;
    <D.26056>:
    if (is_arg != 0) goto <D.26058>; else goto <D.26059>;
    <D.26058>:
    pos.31 = (int) pos;
    set_slot_everywhere (gcfg, pos.31, 2);
    goto <D.26060>;
    <D.26059>:
    cindex = 0;
    goto <D.25218>;
    <D.25217>:
    D.25923 = gcfg->callsites;
    cindex.29 = (unsigned int) cindex;
    D.25925 = cindex.29 * 4;
    D.25926 = D.25923 + D.25925;
    D.25927 = *D.25926;
    D.25928 = D.25927->liveness;
    D.25929 = i / 8;
    D.25930 = (sizetype) D.25929;
    D.25931 = D.25928 + D.25930;
    D.25932 = *D.25931;
    D.25933 = (int) D.25932;
    D.25934 = i % 8;
    D.25935 = D.25933 >> D.25934;
    D.25936 = D.25935 & 1;
    if (D.25936 != 0) goto <D.26061>; else goto <D.26062>;
    <D.26061>:
    pos.31 = (int) pos;
    set_slot (gcfg, pos.31, cindex, 2);
    <D.26062>:
    cindex = cindex + 1;
    <D.25218>:
    D.25939 = gcfg->ncallsites;
    if (D.25939 > cindex) goto <D.25217>; else goto <D.25219>;
    <D.25219>:
    <D.26060>:
    D.25940 = cfg->verbose_level;
    if (D.25940 > 1) goto <D.26063>; else goto <D.26064>;
    <D.26063>:
    D.25952 = ins->data.op[0].const_val;
    if (D.25952 < 0) goto <D.26066>; else goto <D.26067>;
    <D.26066>:
    iftmp.38 = "-";
    goto <D.26068>;
    <D.26067>:
    iftmp.38 = "";
    <D.26068>:
    D.25952 = ins->data.op[0].const_val;
    D.26069 = ABS_EXPR <D.25952>;
    D.25949 = vmv->vreg;
    D.25970 = ins->data.op[1].vtype;
    D.26070 = mono_type_full_name (D.25970);
    printf ("\tbyref at %s0x%x(fp) (R%d, slot = %d): %s\n", iftmp.38, D.26069, D.25949, pos, D.26070);
    <D.26064>:
    // predicted unlikely by continue predictor.
    goto <D.25190>;
    <D.26057>:
    t = mini_type_get_underlying_type (0B, t);
    D.26071 = mini_type_is_reference (cfg, t);
    if (D.26071 == 0) goto <D.26072>; else goto <D.26073>;
    <D.26072>:
    pos.31 = (int) pos;
    set_slot_everywhere (gcfg, pos.31, 0);
    D.25940 = cfg->verbose_level;
    if (D.25940 > 1) goto <D.26074>; else goto <D.26075>;
    <D.26074>:
    if (is_arg != 0) goto <D.26077>; else goto <D.26078>;
    <D.26077>:
    iftmp.39 = " arg";
    goto <D.26079>;
    <D.26078>:
    iftmp.39 = "";
    <D.26079>:
    D.25952 = ins->data.op[0].const_val;
    if (D.25952 < 0) goto <D.26081>; else goto <D.26082>;
    <D.26081>:
    iftmp.40 = "-";
    goto <D.26083>;
    <D.26082>:
    iftmp.40 = "";
    <D.26083>:
    D.25952 = ins->data.op[0].const_val;
    D.26069 = ABS_EXPR <D.25952>;
    D.25949 = vmv->vreg;
    D.25970 = ins->data.op[1].vtype;
    D.26084 = mono_type_full_name (D.25970);
    printf ("\tnoref%s at %s0x%x(fp) (R%d, slot = %d): %s\n", iftmp.39, iftmp.40, D.26069, D.25949, pos, D.26084);
    <D.26075>:
    D.26054 = BIT_FIELD_REF <*t, 8, 56>;
    D.26055 = D.26054 & 64;
    if (D.26055 == 0) goto <D.26085>; else goto <D.26086>;
    <D.26085>:
    D.26087 = t->type;
    D.26088 = D.26087 + 246;
    D.26089 = D.26088 <= 1;
    D.26090 = D.26087 == 13;
    D.26091 = D.26089 | D.26090;
    if (D.26091 != 0) goto <D.26092>; else goto <D.26093>;
    <D.26092>:
    D.26094 = pos + 1;
    D.26095 = (int) D.26094;
    set_slot_everywhere (gcfg, D.26095, 0);
    D.25940 = cfg->verbose_level;
    if (D.25940 > 1) goto <D.26096>; else goto <D.26097>;
    <D.26096>:
    D.25952 = ins->data.op[0].const_val;
    if (D.25952 < 0) goto <D.26099>; else goto <D.26100>;
    <D.26099>:
    iftmp.41 = "-";
    goto <D.26101>;
    <D.26100>:
    iftmp.41 = "";
    <D.26101>:
    D.25952 = ins->data.op[0].const_val;
    if (D.25952 < 0) goto <D.26103>; else goto <D.26104>;
    <D.26103>:
    D.25952 = ins->data.op[0].const_val;
    iftmp.42 = -4 - D.25952;
    goto <D.26105>;
    <D.26104>:
    D.25952 = ins->data.op[0].const_val;
    iftmp.42 = D.25952 + 4;
    <D.26105>:
    D.25949 = vmv->vreg;
    D.26094 = pos + 1;
    D.25970 = ins->data.op[1].vtype;
    D.26106 = mono_type_full_name (D.25970);
    printf ("\tnoref at %s0x%x(fp) (R%d, slot = %d): %s\n", iftmp.41, iftmp.42, D.25949, D.26094, D.26106);
    <D.26097>:
    <D.26093>:
    <D.26086>:
    // predicted unlikely by continue predictor.
    goto <D.25190>;
    <D.26073>:
    D.25960 = ins->flags;
    D.25961 = (int) D.25960;
    D.26107 = D.25961 & 20;
    if (D.26107 != 0) goto <D.26108>; else goto <D.26109>;
    <D.26108>:
    if (is_this == 0) goto <D.26110>; else goto <D.26111>;
    <D.26110>:
    if (is_arg != 0) goto <D.26112>; else goto <D.26113>;
    <D.26112>:
    pos.31 = (int) pos;
    set_slot_everywhere (gcfg, pos.31, 1);
    goto <D.26114>;
    <D.26113>:
    D.25949 = vmv->vreg;
    D.26005 = (unsigned int) D.25949;
    D.26006 = D.26005 * 4;
    D.26007 = pc_offsets + D.26006;
    D.26008 = *D.26007;
    if (D.26008 != 0) goto <D.26115>; else goto <D.26116>;
    <D.26115>:
    pos.31 = (int) pos;
    D.25949 = vmv->vreg;
    D.26005 = (unsigned int) D.25949;
    D.26006 = D.26005 * 4;
    D.26007 = pc_offsets + D.26006;
    D.26008 = *D.26007;
    set_slot_in_range (gcfg, pos.31, 0, D.26008, 2);
    pos.31 = (int) pos;
    D.25949 = vmv->vreg;
    D.26005 = (unsigned int) D.25949;
    D.26006 = D.26005 * 4;
    D.26007 = pc_offsets + D.26006;
    D.26008 = *D.26007;
    D.26117 = cfg->code_size;
    D.26118 = (int) D.26117;
    set_slot_in_range (gcfg, pos.31, D.26008, D.26118, 1);
    goto <D.26119>;
    <D.26116>:
    pos.31 = (int) pos;
    set_slot_everywhere (gcfg, pos.31, 2);
    <D.26119>:
    <D.26114>:
    D.25940 = cfg->verbose_level;
    if (D.25940 > 1) goto <D.26120>; else goto <D.26121>;
    <D.26120>:
    D.25952 = ins->data.op[0].const_val;
    if (D.25952 < 0) goto <D.26123>; else goto <D.26124>;
    <D.26123>:
    iftmp.43 = "-";
    goto <D.26125>;
    <D.26124>:
    iftmp.43 = "";
    <D.26125>:
    D.25952 = ins->data.op[0].const_val;
    D.26069 = ABS_EXPR <D.25952>;
    D.25949 = vmv->vreg;
    D.25970 = ins->data.op[1].vtype;
    D.26126 = mono_type_full_name (D.25970);
    printf ("\tvolatile ref at %s0x%x(fp) (R%d, slot = %d): %s\n", iftmp.43, D.26069, D.25949, pos, D.26126);
    <D.26121>:
    // predicted unlikely by continue predictor.
    goto <D.25190>;
    <D.26111>:
    <D.26109>:
    if (is_arg != 0) goto <D.26127>; else goto <D.26128>;
    <D.26127>:
    pos.31 = (int) pos;
    set_slot_everywhere (gcfg, pos.31, 1);
    goto <D.26129>;
    <D.26128>:
    cindex = 0;
    goto <D.25221>;
    <D.25220>:
    D.25923 = gcfg->callsites;
    cindex.29 = (unsigned int) cindex;
    D.25925 = cindex.29 * 4;
    D.25926 = D.25923 + D.25925;
    D.25927 = *D.25926;
    D.25928 = D.25927->liveness;
    D.25929 = i / 8;
    D.25930 = (sizetype) D.25929;
    D.25931 = D.25928 + D.25930;
    D.25932 = *D.25931;
    D.25933 = (int) D.25932;
    D.25934 = i % 8;
    D.25935 = D.25933 >> D.25934;
    D.25936 = D.25935 & 1;
    if (D.25936 != 0) goto <D.26130>; else goto <D.26131>;
    <D.26130>:
    pos.31 = (int) pos;
    set_slot (gcfg, pos.31, cindex, 1);
    <D.26131>:
    cindex = cindex + 1;
    <D.25221>:
    D.25939 = gcfg->ncallsites;
    if (D.25939 > cindex) goto <D.25220>; else goto <D.25222>;
    <D.25222>:
    <D.26129>:
    D.25940 = cfg->verbose_level;
    if (D.25940 > 1) goto <D.26132>; else goto <D.26133>;
    <D.26132>:
    if (is_arg != 0) goto <D.26135>; else goto <D.26136>;
    <D.26135>:
    iftmp.44 = " arg";
    goto <D.26137>;
    <D.26136>:
    iftmp.44 = "";
    <D.26137>:
    D.25952 = ins->data.op[0].const_val;
    if (D.25952 < 0) goto <D.26139>; else goto <D.26140>;
    <D.26139>:
    iftmp.45 = "-";
    goto <D.26141>;
    <D.26140>:
    iftmp.45 = "";
    <D.26141>:
    D.25952 = ins->data.op[0].const_val;
    D.26069 = ABS_EXPR <D.25952>;
    D.25949 = vmv->vreg;
    D.25970 = ins->data.op[1].vtype;
    D.26142 = mono_type_full_name (D.25970);
    printf ("\tref%s at %s0x%x(fp) (R%d, slot = %d): %s\n", iftmp.44, iftmp.45, D.26069, D.25949, pos, D.26142);
    <D.26133>:
  }
  <D.25190>:
  i = i + 1;
  <D.25224>:
  i.28 = (unsigned int) i;
  D.26143 = cfg->num_varinfo;
  if (i.28 < D.26143) goto <D.25223>; else goto <D.25225>;
  <D.25225>:
  monoeg_g_free (pc_offsets);
}


get_offset_sign (int offset)
{
  const char * D.26145;
  const char * iftmp.46;

  if (offset < 0) goto <D.26147>; else goto <D.26148>;
  <D.26147>:
  iftmp.46 = "-";
  goto <D.26149>;
  <D.26148>:
  iftmp.46 = "+";
  <D.26149>:
  D.26145 = iftmp.46;
  return D.26145;
}


get_offset_val (int offset)
{
  int D.26151;

  D.26151 = ABS_EXPR <offset>;
  return D.26151;
}


get_vtype_bitmap (struct MonoType * t, int * numbits)
{
  struct MonoGenericContainer * D.26155;
  int D.26157;
  gsize * D.26158;
  void * D.26159;
  struct MonoClass * klass;

  klass = mono_class_from_mono_type (t);
  D.26155 = klass->generic_container;
  if (D.26155 != 0B) goto <D.26153>; else goto <D.26156>;
  <D.26156>:
  D.26157 = mono_class_is_open_constructed_type (t);
  if (D.26157 != 0) goto <D.26153>; else goto <D.26154>;
  <D.26153>:
  D.26158 = 0B;
  return D.26158;
  <D.26154>:
  mono_class_compute_gc_descriptor (klass);
  D.26159 = klass->gc_descr;
  D.26158 = mono_gc_get_bitmap_for_descr (D.26159, numbits);
  return D.26158;
}


process_finally_clauses (struct MonoCompile * cfg)
{
  struct MonoMethodHeader * D.26161;
  struct MonoExceptionClause * D.26162;
  unsigned int i.47;
  unsigned int D.26164;
  unsigned int D.26165;
  <unnamed-unsigned:15> D.26168;
  int D.26169;
  unsigned int D.26172;
  unsigned int j.48;
  unsigned int D.26176;
  struct GCCallSite * * D.26177;
  struct GCCallSite * D.26178;
  unsigned int D.26179;
  unsigned int D.26180;
  unsigned int D.26183;
  unsigned int D.26184;
  unsigned int D.26187;
  struct MonoCompileGC * gcfg;
  struct GCCallSite * * callsites;
  int ncallsites;
  gboolean has_finally;
  int i;
  int j;
  int nslots;
  int nregs;

  gcfg = cfg->gc_info;
  ncallsites = gcfg->ncallsites;
  nslots = gcfg->nslots;
  nregs = gcfg->nregs;
  callsites = gcfg->callsites;
  has_finally = 0;
  i = 0;
  goto <D.25271>;
  <D.25270>:
  {
    struct MonoExceptionClause * clause;

    D.26161 = cfg->header;
    D.26162 = D.26161->clauses;
    i.47 = (unsigned int) i;
    D.26164 = i.47 * 24;
    clause = D.26162 + D.26164;
    D.26165 = clause->flags;
    if (D.26165 == 2) goto <D.26166>; else goto <D.26167>;
    <D.26166>:
    has_finally = 1;
    <D.26167>:
  }
  i = i + 1;
  <D.25271>:
  D.26161 = cfg->header;
  D.26168 = D.26161->num_clauses;
  D.26169 = (int) D.26168;
  if (D.26169 > i) goto <D.25270>; else goto <D.25272>;
  <D.25272>:
  if (has_finally != 0) goto <D.26170>; else goto <D.26171>;
  <D.26170>:
  D.26172 = cfg->verbose_level;
  if (D.26172 > 1) goto <D.26173>; else goto <D.26174>;
  <D.26173>:
  printf ("\tMethod has finally clauses, pessimizing live ranges.\n");
  <D.26174>:
  j = 0;
  goto <D.25286>;
  <D.25285>:
  {
    struct MonoBasicBlock * bb;
    struct MonoExceptionClause * clause;
    gboolean is_in_finally;

    j.48 = (unsigned int) j;
    D.26176 = j.48 * 4;
    D.26177 = callsites + D.26176;
    D.26178 = *D.26177;
    bb = D.26178->bb;
    is_in_finally = 0;
    i = 0;
    goto <D.25278>;
    <D.25277>:
    D.26161 = cfg->header;
    D.26162 = D.26161->clauses;
    i.47 = (unsigned int) i;
    D.26164 = i.47 * 24;
    clause = D.26162 + D.26164;
    D.26179 = clause->handler_offset;
    D.26180 = bb->real_offset;
    if (D.26179 <= D.26180) goto <D.26181>; else goto <D.26182>;
    <D.26181>:
    D.26180 = bb->real_offset;
    D.26179 = clause->handler_offset;
    D.26183 = clause->handler_len;
    D.26184 = D.26179 + D.26183;
    if (D.26180 < D.26184) goto <D.26185>; else goto <D.26186>;
    <D.26185>:
    D.26187 = clause->flags;
    if (D.26187 == 2) goto <D.26188>; else goto <D.26189>;
    <D.26188>:
    is_in_finally = 1;
    goto <D.25276>;
    <D.26189>:
    <D.26186>:
    <D.26182>:
    i = i + 1;
    <D.25278>:
    D.26161 = cfg->header;
    D.26168 = D.26161->num_clauses;
    D.26169 = (int) D.26168;
    if (D.26169 > i) goto <D.25277>; else goto <D.25276>;
    <D.25276>:
    if (is_in_finally != 0) goto <D.26190>; else goto <D.26191>;
    <D.26190>:
    i = 0;
    goto <D.25280>;
    <D.25279>:
    set_slot (gcfg, i, j, 2);
    i = i + 1;
    <D.25280>:
    if (i < nslots) goto <D.25279>; else goto <D.25281>;
    <D.25281>:
    i = 0;
    goto <D.25283>;
    <D.25282>:
    set_reg_slot (gcfg, i, j, 2);
    i = i + 1;
    <D.25283>:
    if (i < nregs) goto <D.25282>; else goto <D.25284>;
    <D.25284>:
    <D.26191>:
  }
  j = j + 1;
  <D.25286>:
  if (j < ncallsites) goto <D.25285>; else goto <D.25287>;
  <D.25287>:
  <D.26171>:
}


create_map (struct MonoCompile * cfg)
{
  guint8 * D.26192;
  int D.26193;
  int D.26194;
  guint8 * D.26197;
  int D.26198;
  int D.26207;
  int D.26208;
  int D.26212;
  int D.26213;
  int D.26215;
  int D.26216;
  int D.26217;
  _Bool D.26225;
  long int D.26226;
  long int D.26227;
  _Bool D.26230;
  long int D.26231;
  long int D.26232;
  unsigned int D.26235;
  int D.26236;
  unsigned int D.26237;
  unsigned int D.26238;
  guint8 * D.26241;
  int D.26242;
  int D.26243;
  guint8 * D.26246;
  int D.26247;
  unsigned int D.26252;
  unsigned int D.26255;
  int D.26258;
  int D.26259;
  int D.26260;
  int D.26261;
  int iftmp.49;
  int iftmp.50;
  int D.26270;
  int iftmp.51;
  int D.26275;
  int iftmp.52;
  struct MonoMemPool * D.26280;
  unsigned int D.26281;
  unsigned char D.26282;
  int D.26283;
  int D.26284;
  int D.26285;
  int D.26286;
  unsigned char D.26287;
  <unnamed-unsigned:1> D.26288;
  unsigned char D.26289;
  <unnamed-unsigned:1> D.26290;
  unsigned char D.26291;
  <unnamed-unsigned:1> D.26292;
  unsigned char D.26293;
  <unnamed-unsigned:1> D.26294;
  _Bool D.26295;
  long int D.26296;
  long int D.26297;
  unsigned char D.26300;
  unsigned char D.26301;
  unsigned int bitmaps_size.53;
  unsigned int bitmaps_offset.54;
  unsigned int D.26306;
  int D.26307;
  int D.26310;
  unsigned int D.26313;
  int D.26314;
  unsigned int D.26319;
  unsigned int D.26320;
  int D.26323;
  unsigned int D.26328;
  unsigned int D.26329;
  int D.26332;
  unsigned int D.26335;
  guint8 * endbuf.55;
  int endbuf.56;
  int buf.57;
  int D.26345;
  _Bool D.26346;
  long int D.26347;
  long int D.26348;
  unsigned char D.26351;
  int D.26352;
  int D.26353;
  int D.26354;
  int D.26355;
  int D.26356;
  unsigned int D.26357;
  int D.26358;
  int D.26359;
  unsigned int D.26360;
  unsigned int D.26361;
  unsigned int D.26362;
  struct MonoDomain * D.26363;
  unsigned int alloc_size.58;
  unsigned int encoded_size.59;
  sizetype encoded_size.60;
  int p.61;
  int D.26368;
  int D.26369;
  sizetype i.62;
  guint8 * D.26373;
  unsigned int i.63;
  unsigned int D.26375;
  struct GCCallSite * * D.26376;
  struct GCCallSite * D.26377;
  int D.26378;
  unsigned char D.26379;
  int D.26380;
  unsigned int D.26381;
  unsigned int ncallsites.64;
  unsigned int D.26383;
  int D.26384;
  unsigned int D.26388;
  guint16 * D.26389;
  short unsigned int D.26390;
  int D.26391;
  unsigned int D.26392;
  unsigned int D.26393;
  unsigned int D.26394;
  int D.26395;
  guint32 * D.26397;
  unsigned int D.26398;
  int D.26399;
  unsigned int D.26400;
  unsigned int D.26401;
  unsigned int D.26402;
  int D.26403;
  int D.26404;
  sizetype D.26405;
  unsigned int bitmaps_size.65;
  sizetype bitmaps_size.66;
  int emap.67;
  int D.26409;
  _Bool D.26410;
  long int D.26411;
  long int D.26412;
  int D.26415;
  int D.26416;
  int D.26417;
  int D.26418;
  int D.26419;
  int D.26420;
  int D.26421;
  unsigned int D.26422;
  unsigned int encoded_size.68;
  unsigned int D.26424;
  int D.26425;
  struct MonoJitInfo * D.26426;
  unsigned int alloc_size.69;
  int D.26428;
  int D.26429;
  int D.26430;
  int D.26431;
  int D.26432;
  int D.26433;
  int D.26434;
  int D.26435;
  struct GCMap * map;
  int i;
  int j;
  int nregs;
  int nslots;
  int nref_regs;
  int npin_regs;
  int alloc_size;
  int bitmaps_size;
  int bitmaps_offset;
  int ntypes[16];
  int stack_bitmap_width;
  int stack_bitmap_size;
  int reg_ref_bitmap_width;
  int reg_ref_bitmap_size;
  int reg_pin_bitmap_width;
  int reg_pin_bitmap_size;
  int bindex;
  int start;
  int end;
  gboolean has_ref_slots;
  gboolean has_pin_slots;
  gboolean has_ref_regs;
  gboolean has_pin_regs;
  struct MonoCompileGC * gcfg;
  struct GCCallSite * * callsites;
  int ncallsites;
  guint8 * bitmap;
  guint8 * bitmaps;
  guint32 reg_ref_mask;
  guint32 reg_pin_mask;

  try
    {
      gcfg = cfg->gc_info;
      ncallsites = gcfg->ncallsites;
      nslots = gcfg->nslots;
      nregs = gcfg->nregs;
      callsites = gcfg->callsites;
      has_ref_slots = 0;
      has_pin_slots = 0;
      start = -1;
      end = -1;
      memset (&ntypes, 0, 64);
      i = 0;
      goto <D.25386>;
      <D.25385>:
      {
        gboolean has_ref;
        gboolean has_pin;

        has_ref = 0;
        has_pin = 0;
        D.26192 = gcfg->stack_pin_bitmap;
        D.26193 = gcfg->stack_bitmap_width;
        D.26194 = has_bit_set (D.26192, D.26193, i);
        if (D.26194 != 0) goto <D.26195>; else goto <D.26196>;
        <D.26195>:
        has_pin = 1;
        <D.26196>:
        D.26197 = gcfg->stack_ref_bitmap;
        D.26193 = gcfg->stack_bitmap_width;
        D.26198 = has_bit_set (D.26197, D.26193, i);
        if (D.26198 != 0) goto <D.26199>; else goto <D.26200>;
        <D.26199>:
        has_ref = 1;
        <D.26200>:
        if (has_ref != 0) goto <D.26201>; else goto <D.26202>;
        <D.26201>:
        has_ref_slots = 1;
        <D.26202>:
        if (has_pin != 0) goto <D.26203>; else goto <D.26204>;
        <D.26203>:
        has_pin_slots = 1;
        <D.26204>:
        if (has_ref != 0) goto <D.26205>; else goto <D.26206>;
        <D.26205>:
        D.26207 = ntypes[1];
        D.26208 = D.26207 + 1;
        ntypes[1] = D.26208;
        goto <D.26209>;
        <D.26206>:
        if (has_pin != 0) goto <D.26210>; else goto <D.26211>;
        <D.26210>:
        D.26212 = ntypes[2];
        D.26213 = D.26212 + 1;
        ntypes[2] = D.26213;
        goto <D.26214>;
        <D.26211>:
        D.26215 = ntypes[0];
        D.26216 = D.26215 + 1;
        ntypes[0] = D.26216;
        <D.26214>:
        <D.26209>:
        D.26217 = has_ref | has_pin;
        if (D.26217 != 0) goto <D.26218>; else goto <D.26219>;
        <D.26218>:
        if (start == -1) goto <D.26220>; else goto <D.26221>;
        <D.26220>:
        start = i;
        <D.26221>:
        end = i + 1;
        <D.26219>:
      }
      i = i + 1;
      <D.25386>:
      if (i < nslots) goto <D.25385>; else goto <D.25387>;
      <D.25387>:
      if (start == -1) goto <D.26222>; else goto <D.26223>;
      <D.26222>:
      end = nslots;
      start = end;
      goto <D.26224>;
      <D.26223>:
      D.26225 = start == -1;
      D.26226 = (long int) D.26225;
      D.26227 = __builtin_expect (D.26226, 0);
      if (D.26227 != 0) goto <D.26228>; else goto <D.26229>;
      <D.26228>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 2214, "start != -1");
      <D.26229>:
      D.26230 = start >= end;
      D.26231 = (long int) D.26230;
      D.26232 = __builtin_expect (D.26231, 0);
      if (D.26232 != 0) goto <D.26233>; else goto <D.26234>;
      <D.26233>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 2215, "start < end");
      <D.26234>:
      <D.26224>:
      has_ref_regs = 0;
      has_pin_regs = 0;
      reg_ref_mask = 0;
      reg_pin_mask = 0;
      nref_regs = 0;
      npin_regs = 0;
      i = 0;
      goto <D.25392>;
      <D.25391>:
      {
        gboolean has_ref;
        gboolean has_pin;

        has_ref = 0;
        has_pin = 0;
        D.26235 = cfg->used_int_regs;
        D.26236 = 1 << i;
        D.26237 = (unsigned int) D.26236;
        D.26238 = D.26235 & D.26237;
        if (D.26238 == 0) goto <D.26239>; else goto <D.26240>;
        <D.26239>:
        // predicted unlikely by continue predictor.
        goto <D.25390>;
        <D.26240>:
        D.26241 = gcfg->reg_pin_bitmap;
        D.26242 = gcfg->reg_bitmap_width;
        D.26243 = has_bit_set (D.26241, D.26242, i);
        if (D.26243 != 0) goto <D.26244>; else goto <D.26245>;
        <D.26244>:
        has_pin = 1;
        <D.26245>:
        D.26246 = gcfg->reg_ref_bitmap;
        D.26242 = gcfg->reg_bitmap_width;
        D.26247 = has_bit_set (D.26246, D.26242, i);
        if (D.26247 != 0) goto <D.26248>; else goto <D.26249>;
        <D.26248>:
        has_ref = 1;
        <D.26249>:
        if (has_ref != 0) goto <D.26250>; else goto <D.26251>;
        <D.26250>:
        D.26236 = 1 << i;
        D.26252 = (unsigned int) D.26236;
        reg_ref_mask = D.26252 | reg_ref_mask;
        has_ref_regs = 1;
        nref_regs = nref_regs + 1;
        <D.26251>:
        if (has_pin != 0) goto <D.26253>; else goto <D.26254>;
        <D.26253>:
        D.26236 = 1 << i;
        D.26252 = (unsigned int) D.26236;
        reg_pin_mask = D.26252 | reg_pin_mask;
        has_pin_regs = 1;
        npin_regs = npin_regs + 1;
        <D.26254>:
      }
      <D.25390>:
      i = i + 1;
      <D.25392>:
      if (i < nregs) goto <D.25391>; else goto <D.25393>;
      <D.25393>:
      D.26255 = cfg->verbose_level;
      if (D.26255 > 1) goto <D.26256>; else goto <D.26257>;
      <D.26256>:
      D.26207 = ntypes[1];
      D.26215 = ntypes[0];
      D.26212 = ntypes[2];
      printf ("Slots: %d Start: %d End: %d Refs: %d NoRefs: %d Pin: %d Callsites: %d\n", nslots, start, end, D.26207, D.26215, D.26212, ncallsites);
      <D.26257>:
      D.26258 = end - start;
      D.26259 = D.26258 + 7;
      stack_bitmap_width = D.26259 >> 3;
      stack_bitmap_size = stack_bitmap_width * ncallsites;
      D.26260 = nref_regs + 7;
      reg_ref_bitmap_width = D.26260 >> 3;
      reg_ref_bitmap_size = reg_ref_bitmap_width * ncallsites;
      D.26261 = npin_regs + 7;
      reg_pin_bitmap_width = D.26261 >> 3;
      reg_pin_bitmap_size = reg_pin_bitmap_width * ncallsites;
      if (has_ref_slots != 0) goto <D.26263>; else goto <D.26264>;
      <D.26263>:
      iftmp.49 = stack_bitmap_size;
      goto <D.26265>;
      <D.26264>:
      iftmp.49 = 0;
      <D.26265>:
      if (has_pin_slots != 0) goto <D.26267>; else goto <D.26268>;
      <D.26267>:
      iftmp.50 = stack_bitmap_size;
      goto <D.26269>;
      <D.26268>:
      iftmp.50 = 0;
      <D.26269>:
      D.26270 = iftmp.49 + iftmp.50;
      if (has_ref_regs != 0) goto <D.26272>; else goto <D.26273>;
      <D.26272>:
      iftmp.51 = reg_ref_bitmap_size;
      goto <D.26274>;
      <D.26273>:
      iftmp.51 = 0;
      <D.26274>:
      D.26275 = D.26270 + iftmp.51;
      if (has_pin_regs != 0) goto <D.26277>; else goto <D.26278>;
      <D.26277>:
      iftmp.52 = reg_pin_bitmap_size;
      goto <D.26279>;
      <D.26278>:
      iftmp.52 = 0;
      <D.26279>:
      bitmaps_size = D.26275 + iftmp.52;
      D.26280 = cfg->mempool;
      map = mono_mempool_alloc0 (D.26280, 60);
      D.26281 = cfg->frame_reg;
      D.26282 = (unsigned char) D.26281;
      map->frame_reg = D.26282;
      D.26283 = gcfg->min_offset;
      map->start_offset = D.26283;
      D.26283 = gcfg->min_offset;
      D.26284 = nslots * 4;
      D.26285 = D.26283 + D.26284;
      map->end_offset = D.26285;
      D.26286 = start * 4;
      map->map_offset = D.26286;
      D.26258 = end - start;
      map->nslots = D.26258;
      D.26287 = (unsigned char) has_ref_slots;
      D.26288 = (<unnamed-unsigned:1>) D.26287;
      map->has_ref_slots = D.26288;
      D.26289 = (unsigned char) has_pin_slots;
      D.26290 = (<unnamed-unsigned:1>) D.26289;
      map->has_pin_slots = D.26290;
      D.26291 = (unsigned char) has_ref_regs;
      D.26292 = (<unnamed-unsigned:1>) D.26291;
      map->has_ref_regs = D.26292;
      D.26293 = (unsigned char) has_pin_regs;
      D.26294 = (<unnamed-unsigned:1>) D.26293;
      map->has_pin_regs = D.26294;
      D.26295 = nregs > 31;
      D.26296 = (long int) D.26295;
      D.26297 = __builtin_expect (D.26296, 0);
      if (D.26297 != 0) goto <D.26298>; else goto <D.26299>;
      <D.26298>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 2273, "nregs < 32");
      <D.26299>:
      D.26235 = cfg->used_int_regs;
      map->used_int_regs = D.26235;
      map->reg_ref_mask = reg_ref_mask;
      map->reg_pin_mask = reg_pin_mask;
      D.26300 = (unsigned char) nref_regs;
      map->nref_regs = D.26300;
      D.26301 = (unsigned char) npin_regs;
      map->npin_regs = D.26301;
      D.26280 = cfg->mempool;
      bitmaps_size.53 = (unsigned int) bitmaps_size;
      bitmaps = mono_mempool_alloc0 (D.26280, bitmaps_size.53);
      bitmaps_offset = 0;
      if (has_ref_slots != 0) goto <D.26303>; else goto <D.26304>;
      <D.26303>:
      bitmaps_offset.54 = (unsigned int) bitmaps_offset;
      map->stack_ref_bitmap_offset = bitmaps_offset.54;
      bitmaps_offset = bitmaps_offset + stack_bitmap_size;
      D.26306 = map->stack_ref_bitmap_offset;
      bitmap = bitmaps + D.26306;
      i = 0;
      goto <D.25398>;
      <D.25397>:
      j = 0;
      goto <D.25395>;
      <D.25394>:
      D.26197 = gcfg->stack_ref_bitmap;
      D.26193 = gcfg->stack_bitmap_width;
      D.26307 = get_bit (D.26197, D.26193, i, j);
      if (D.26307 != 0) goto <D.26308>; else goto <D.26309>;
      <D.26308>:
      D.26310 = i - start;
      set_bit (bitmap, stack_bitmap_width, j, D.26310);
      <D.26309>:
      j = j + 1;
      <D.25395>:
      if (j < ncallsites) goto <D.25394>; else goto <D.25396>;
      <D.25396>:
      i = i + 1;
      <D.25398>:
      if (i < nslots) goto <D.25397>; else goto <D.25399>;
      <D.25399>:
      <D.26304>:
      if (has_pin_slots != 0) goto <D.26311>; else goto <D.26312>;
      <D.26311>:
      bitmaps_offset.54 = (unsigned int) bitmaps_offset;
      map->stack_pin_bitmap_offset = bitmaps_offset.54;
      bitmaps_offset = bitmaps_offset + stack_bitmap_size;
      D.26313 = map->stack_pin_bitmap_offset;
      bitmap = bitmaps + D.26313;
      i = 0;
      goto <D.25404>;
      <D.25403>:
      j = 0;
      goto <D.25401>;
      <D.25400>:
      D.26192 = gcfg->stack_pin_bitmap;
      D.26193 = gcfg->stack_bitmap_width;
      D.26314 = get_bit (D.26192, D.26193, i, j);
      if (D.26314 != 0) goto <D.26315>; else goto <D.26316>;
      <D.26315>:
      D.26310 = i - start;
      set_bit (bitmap, stack_bitmap_width, j, D.26310);
      <D.26316>:
      j = j + 1;
      <D.25401>:
      if (j < ncallsites) goto <D.25400>; else goto <D.25402>;
      <D.25402>:
      i = i + 1;
      <D.25404>:
      if (i < nslots) goto <D.25403>; else goto <D.25405>;
      <D.25405>:
      <D.26312>:
      if (has_ref_regs != 0) goto <D.26317>; else goto <D.26318>;
      <D.26317>:
      bitmaps_offset.54 = (unsigned int) bitmaps_offset;
      map->reg_ref_bitmap_offset = bitmaps_offset.54;
      bitmaps_offset = bitmaps_offset + reg_ref_bitmap_size;
      D.26319 = map->reg_ref_bitmap_offset;
      bitmap = bitmaps + D.26319;
      bindex = 0;
      i = 0;
      goto <D.25410>;
      <D.25409>:
      D.26236 = 1 << i;
      D.26252 = (unsigned int) D.26236;
      D.26320 = D.26252 & reg_ref_mask;
      if (D.26320 != 0) goto <D.26321>; else goto <D.26322>;
      <D.26321>:
      j = 0;
      goto <D.25407>;
      <D.25406>:
      D.26246 = gcfg->reg_ref_bitmap;
      D.26242 = gcfg->reg_bitmap_width;
      D.26323 = get_bit (D.26246, D.26242, i, j);
      if (D.26323 != 0) goto <D.26324>; else goto <D.26325>;
      <D.26324>:
      set_bit (bitmap, reg_ref_bitmap_width, j, bindex);
      <D.26325>:
      j = j + 1;
      <D.25407>:
      if (j < ncallsites) goto <D.25406>; else goto <D.25408>;
      <D.25408>:
      bindex = bindex + 1;
      <D.26322>:
      i = i + 1;
      <D.25410>:
      if (i < nregs) goto <D.25409>; else goto <D.25411>;
      <D.25411>:
      <D.26318>:
      if (has_pin_regs != 0) goto <D.26326>; else goto <D.26327>;
      <D.26326>:
      bitmaps_offset.54 = (unsigned int) bitmaps_offset;
      map->reg_pin_bitmap_offset = bitmaps_offset.54;
      bitmaps_offset = bitmaps_offset + reg_pin_bitmap_size;
      D.26328 = map->reg_pin_bitmap_offset;
      bitmap = bitmaps + D.26328;
      bindex = 0;
      i = 0;
      goto <D.25416>;
      <D.25415>:
      D.26236 = 1 << i;
      D.26252 = (unsigned int) D.26236;
      D.26329 = D.26252 & reg_pin_mask;
      if (D.26329 != 0) goto <D.26330>; else goto <D.26331>;
      <D.26330>:
      j = 0;
      goto <D.25413>;
      <D.25412>:
      D.26241 = gcfg->reg_pin_bitmap;
      D.26242 = gcfg->reg_bitmap_width;
      D.26332 = get_bit (D.26241, D.26242, i, j);
      if (D.26332 != 0) goto <D.26333>; else goto <D.26334>;
      <D.26333>:
      set_bit (bitmap, reg_pin_bitmap_width, j, bindex);
      <D.26334>:
      j = j + 1;
      <D.25413>:
      if (j < ncallsites) goto <D.25412>; else goto <D.25414>;
      <D.25414>:
      bindex = bindex + 1;
      <D.26331>:
      i = i + 1;
      <D.25416>:
      if (i < nregs) goto <D.25415>; else goto <D.25417>;
      <D.25417>:
      <D.26327>:
      map->ncallsites = ncallsites;
      D.26335 = cfg->code_len;
      if (D.26335 <= 255) goto <D.26336>; else goto <D.26337>;
      <D.26336>:
      map->callsite_entry_size = 1;
      goto <D.26338>;
      <D.26337>:
      D.26335 = cfg->code_len;
      if (D.26335 <= 65535) goto <D.26339>; else goto <D.26340>;
      <D.26339>:
      map->callsite_entry_size = 2;
      goto <D.26341>;
      <D.26340>:
      map->callsite_entry_size = 4;
      <D.26341>:
      <D.26338>:
      {
        guint8 buf[256];
        guint8 * endbuf;
        struct GCEncodedMap * emap;
        int encoded_size;
        guint8 * p;

        try
          {
            encode_gc_map (map, &buf, &endbuf);
            endbuf.55 = endbuf;
            endbuf.56 = (int) endbuf.55;
            buf.57 = (int) &buf;
            D.26345 = endbuf.56 - buf.57;
            D.26346 = D.26345 > 255;
            D.26347 = (long int) D.26346;
            D.26348 = __builtin_expect (D.26347, 0);
            if (D.26348 != 0) goto <D.26349>; else goto <D.26350>;
            <D.26349>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 2358, "endbuf - buf < 256");
            <D.26350>:
            endbuf.55 = endbuf;
            endbuf.56 = (int) endbuf.55;
            buf.57 = (int) &buf;
            encoded_size = endbuf.56 - buf.57;
            D.26351 = map->callsite_entry_size;
            D.26352 = (int) D.26351;
            D.26353 = D.26352 + -1;
            D.26354 = D.26353 + encoded_size;
            D.26351 = map->callsite_entry_size;
            D.26352 = (int) D.26351;
            D.26355 = -D.26352;
            D.26356 = D.26354 & D.26355;
            D.26357 = (unsigned int) D.26356;
            D.26351 = map->callsite_entry_size;
            D.26352 = (int) D.26351;
            D.26358 = map->ncallsites;
            D.26359 = D.26352 * D.26358;
            D.26360 = (unsigned int) D.26359;
            D.26361 = D.26357 + D.26360;
            bitmaps_size.53 = (unsigned int) bitmaps_size;
            D.26362 = D.26361 + bitmaps_size.53;
            alloc_size = (int) D.26362;
            D.26363 = cfg->domain;
            alloc_size.58 = (unsigned int) alloc_size;
            emap = mono_domain_alloc0 (D.26363, alloc_size.58);
            p = &emap->encoded[0];
            encoded_size.59 = (unsigned int) encoded_size;
            memcpy (p, &buf, encoded_size.59);
            encoded_size.60 = (sizetype) encoded_size;
            p = p + encoded_size.60;
            D.26351 = map->callsite_entry_size;
            D.26352 = (int) D.26351;
            D.26353 = D.26352 + -1;
            p.61 = (int) p;
            D.26368 = D.26353 + p.61;
            D.26351 = map->callsite_entry_size;
            D.26352 = (int) D.26351;
            D.26355 = -D.26352;
            D.26369 = D.26368 & D.26355;
            p = (guint8 *) D.26369;
            D.26351 = map->callsite_entry_size;
            if (D.26351 == 1) goto <D.26370>; else goto <D.26371>;
            <D.26370>:
            {
              guint8 * offsets;

              offsets = p;
              i = 0;
              goto <D.25425>;
              <D.25424>:
              i.62 = (sizetype) i;
              D.26373 = offsets + i.62;
              i.63 = (unsigned int) i;
              D.26375 = i.63 * 4;
              D.26376 = callsites + D.26375;
              D.26377 = *D.26376;
              D.26378 = D.26377->pc_offset;
              D.26379 = (unsigned char) D.26378;
              *D.26373 = D.26379;
              i = i + 1;
              <D.25425>:
              if (i < ncallsites) goto <D.25424>; else goto <D.25426>;
              <D.25426>:
              D.26380 = stats.gc_callsites8_size;
              D.26381 = (unsigned int) D.26380;
              ncallsites.64 = (unsigned int) ncallsites;
              D.26383 = D.26381 + ncallsites.64;
              D.26384 = (int) D.26383;
              stats.gc_callsites8_size = D.26384;
            }
            goto <D.26385>;
            <D.26371>:
            D.26351 = map->callsite_entry_size;
            if (D.26351 == 2) goto <D.26386>; else goto <D.26387>;
            <D.26386>:
            {
              guint16 * offsets;

              offsets = p;
              i = 0;
              goto <D.25429>;
              <D.25428>:
              i.63 = (unsigned int) i;
              D.26388 = i.63 * 2;
              D.26389 = offsets + D.26388;
              i.63 = (unsigned int) i;
              D.26375 = i.63 * 4;
              D.26376 = callsites + D.26375;
              D.26377 = *D.26376;
              D.26378 = D.26377->pc_offset;
              D.26390 = (short unsigned int) D.26378;
              *D.26389 = D.26390;
              i = i + 1;
              <D.25429>:
              if (i < ncallsites) goto <D.25428>; else goto <D.25430>;
              <D.25430>:
              D.26391 = stats.gc_callsites16_size;
              D.26392 = (unsigned int) D.26391;
              ncallsites.64 = (unsigned int) ncallsites;
              D.26393 = ncallsites.64 * 2;
              D.26394 = D.26392 + D.26393;
              D.26395 = (int) D.26394;
              stats.gc_callsites16_size = D.26395;
            }
            goto <D.26396>;
            <D.26387>:
            {
              guint32 * offsets;

              offsets = p;
              i = 0;
              goto <D.25433>;
              <D.25432>:
              i.63 = (unsigned int) i;
              D.26375 = i.63 * 4;
              D.26397 = offsets + D.26375;
              i.63 = (unsigned int) i;
              D.26375 = i.63 * 4;
              D.26376 = callsites + D.26375;
              D.26377 = *D.26376;
              D.26378 = D.26377->pc_offset;
              D.26398 = (unsigned int) D.26378;
              *D.26397 = D.26398;
              i = i + 1;
              <D.25433>:
              if (i < ncallsites) goto <D.25432>; else goto <D.25434>;
              <D.25434>:
              D.26399 = stats.gc_callsites32_size;
              D.26400 = (unsigned int) D.26399;
              ncallsites.64 = (unsigned int) ncallsites;
              D.26401 = ncallsites.64 * 4;
              D.26402 = D.26400 + D.26401;
              D.26403 = (int) D.26402;
              stats.gc_callsites32_size = D.26403;
            }
            <D.26396>:
            <D.26385>:
            D.26351 = map->callsite_entry_size;
            D.26352 = (int) D.26351;
            D.26404 = D.26352 * ncallsites;
            D.26405 = (sizetype) D.26404;
            p = p + D.26405;
            bitmaps_size.65 = (unsigned int) bitmaps_size;
            memcpy (p, bitmaps, bitmaps_size.65);
            bitmaps_size.66 = (sizetype) bitmaps_size;
            p = p + bitmaps_size.66;
            p.61 = (int) p;
            emap.67 = (int) emap;
            D.26409 = p.61 - emap.67;
            D.26410 = D.26409 > alloc_size;
            D.26411 = (long int) D.26410;
            D.26412 = __builtin_expect (D.26411, 0);
            if (D.26412 != 0) goto <D.26413>; else goto <D.26414>;
            <D.26413>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 2396, "(guint8*)p - (guint8*)emap <= alloc_size");
            <D.26414>:
            D.26415 = stats.gc_maps_size;
            D.26416 = D.26415 + alloc_size;
            stats.gc_maps_size = D.26416;
            D.26417 = stats.gc_callsites_size;
            D.26351 = map->callsite_entry_size;
            D.26352 = (int) D.26351;
            D.26404 = D.26352 * ncallsites;
            D.26418 = D.26417 + D.26404;
            stats.gc_callsites_size = D.26418;
            D.26419 = stats.gc_bitmaps_size;
            D.26420 = D.26419 + bitmaps_size;
            stats.gc_bitmaps_size = D.26420;
            D.26421 = stats.gc_map_struct_size;
            D.26422 = (unsigned int) D.26421;
            encoded_size.68 = (unsigned int) encoded_size;
            D.26424 = D.26422 + encoded_size.68;
            D.26425 = (int) D.26424;
            stats.gc_map_struct_size = D.26425;
            D.26426 = cfg->jit_info;
            D.26426->gc_info = emap;
            cfg->gc_map = emap;
            alloc_size.69 = (unsigned int) alloc_size;
            cfg->gc_map_size = alloc_size.69;
          }
        finally
          {
            buf = {CLOBBER};
            endbuf = {CLOBBER};
          }
      }
      D.26428 = stats.all_slots;
      D.26429 = D.26428 + nslots;
      stats.all_slots = D.26429;
      D.26430 = stats.ref_slots;
      D.26207 = ntypes[1];
      D.26431 = D.26430 + D.26207;
      stats.ref_slots = D.26431;
      D.26432 = stats.noref_slots;
      D.26215 = ntypes[0];
      D.26433 = D.26432 + D.26215;
      stats.noref_slots = D.26433;
      D.26434 = stats.pin_slots;
      D.26212 = ntypes[2];
      D.26435 = D.26434 + D.26212;
      stats.pin_slots = D.26435;
    }
  finally
    {
      ntypes = {CLOBBER};
    }
}


has_bit_set (guint8 * bitmap, int width, int slot)
{
  int D.26436;
  sizetype D.26437;
  guint8 * D.26438;
  unsigned char D.26439;
  gboolean D.26441;
  _Bool D.26442;
  int i;
  int pos;

  pos = width * slot;
  i = 0;
  goto <D.25348>;
  <D.25347>:
  D.26436 = pos + i;
  D.26437 = (sizetype) D.26436;
  D.26438 = bitmap + D.26437;
  D.26439 = *D.26438;
  if (D.26439 != 0) goto <D.25346>; else goto <D.26440>;
  <D.26440>:
  i = i + 1;
  <D.25348>:
  if (i < width) goto <D.25347>; else goto <D.25346>;
  <D.25346>:
  D.26442 = i < width;
  D.26441 = (gboolean) D.26442;
  return D.26441;
}


get_bit (guint8 * bitmap, int width, int y, int x)
{
  int D.26444;
  int D.26445;
  int D.26446;
  int D.26447;
  sizetype D.26448;
  guint8 * D.26449;
  unsigned char D.26450;
  int D.26451;
  int D.26452;
  int D.26453;

  D.26445 = width * y;
  D.26446 = x / 8;
  D.26447 = D.26445 + D.26446;
  D.26448 = (sizetype) D.26447;
  D.26449 = bitmap + D.26448;
  D.26450 = *D.26449;
  D.26451 = (int) D.26450;
  D.26452 = x % 8;
  D.26453 = 1 << D.26452;
  D.26444 = D.26451 & D.26453;
  return D.26444;
}


encode_gc_map (struct GCMap * map, guint8 * buf, guint8 * * endbuf)
{
  int D.26455;
  int D.26456;
  guint8 * buf.70;
  int D.26458;
  int D.26459;
  int D.26460;
  int D.26461;
  int D.26462;
  unsigned int D.26463;
  unsigned char D.26464;
  _Bool D.26465;
  long int D.26466;
  long int D.26467;
  unsigned char D.26470;
  int D.26471;
  int D.26472;
  _Bool D.26473;
  long int D.26474;
  long int D.26475;
  unsigned char D.26478;
  unsigned char D.26479;
  _Bool D.26480;
  int D.26481;
  int iftmp.71;
  unsigned char D.26483;
  int D.26487;
  int D.26488;
  int D.26489;
  int D.26490;
  int D.26491;
  int D.26492;
  int D.26493;
  int D.26494;
  int D.26495;
  int D.26496;
  unsigned int D.26497;
  unsigned int D.26498;
  unsigned int D.26499;
  unsigned int D.26500;
  unsigned char D.26501;
  unsigned int D.26504;
  unsigned int D.26505;
  unsigned char D.26506;
  unsigned int D.26509;
  unsigned int D.26510;
  int D.26511;
  unsigned int D.26512;
  guint32 flags;
  guint32 freg;

  D.26455 = map->start_offset;
  D.26456 = D.26455 / 4;
  buf.70 = buf;
  encode_sleb128 (D.26456, buf.70, &buf);
  D.26458 = map->end_offset;
  D.26459 = D.26458 / 4;
  buf.70 = buf;
  encode_sleb128 (D.26459, buf.70, &buf);
  D.26460 = map->map_offset;
  D.26461 = D.26460 / 4;
  buf.70 = buf;
  encode_sleb128 (D.26461, buf.70, &buf);
  D.26462 = map->nslots;
  D.26463 = (unsigned int) D.26462;
  buf.70 = buf;
  encode_uleb128 (D.26463, buf.70, &buf);
  D.26464 = map->callsite_entry_size;
  D.26465 = D.26464 > 4;
  D.26466 = (long int) D.26465;
  D.26467 = __builtin_expect (D.26466, 0);
  if (D.26467 != 0) goto <D.26468>; else goto <D.26469>;
  <D.26468>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 487, "map->callsite_entry_size <= 4");
  <D.26469>:
  D.26470 = map->frame_reg;
  D.26471 = (int) D.26470;
  D.26472 = encode_frame_reg (D.26471);
  freg = (guint32) D.26472;
  D.26473 = freg > 1;
  D.26474 = (long int) D.26473;
  D.26475 = __builtin_expect (D.26474, 0);
  if (D.26475 != 0) goto <D.26476>; else goto <D.26477>;
  <D.26476>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 489, "freg < 2");
  <D.26477>:
  D.26478 = BIT_FIELD_REF <*map, 8, 144>;
  D.26479 = D.26478 & 2;
  D.26480 = D.26479 != 0;
  D.26481 = (int) D.26480;
  D.26478 = BIT_FIELD_REF <*map, 8, 144>;
  D.26483 = D.26478 & 1;
  if (D.26483 != 0) goto <D.26484>; else goto <D.26485>;
  <D.26484>:
  iftmp.71 = 2;
  goto <D.26486>;
  <D.26485>:
  iftmp.71 = 0;
  <D.26486>:
  D.26487 = D.26481 | iftmp.71;
  D.26478 = BIT_FIELD_REF <*map, 8, 144>;
  D.26488 = (int) D.26478;
  D.26489 = D.26488 & 4;
  D.26490 = D.26487 | D.26489;
  D.26478 = BIT_FIELD_REF <*map, 8, 144>;
  D.26488 = (int) D.26478;
  D.26491 = D.26488 & 8;
  D.26492 = D.26490 | D.26491;
  D.26464 = map->callsite_entry_size;
  D.26493 = (int) D.26464;
  D.26494 = D.26493 + -1;
  D.26495 = D.26494 << 4;
  D.26496 = D.26492 | D.26495;
  D.26497 = (unsigned int) D.26496;
  D.26498 = freg << 6;
  flags = D.26497 | D.26498;
  buf.70 = buf;
  encode_uleb128 (flags, buf.70, &buf);
  D.26499 = map->used_int_regs;
  D.26500 = encode_regmask (D.26499);
  buf.70 = buf;
  encode_uleb128 (D.26500, buf.70, &buf);
  D.26478 = BIT_FIELD_REF <*map, 8, 144>;
  D.26501 = D.26478 & 4;
  if (D.26501 != 0) goto <D.26502>; else goto <D.26503>;
  <D.26502>:
  D.26504 = map->reg_ref_mask;
  D.26505 = encode_regmask (D.26504);
  buf.70 = buf;
  encode_uleb128 (D.26505, buf.70, &buf);
  <D.26503>:
  D.26478 = BIT_FIELD_REF <*map, 8, 144>;
  D.26506 = D.26478 & 8;
  if (D.26506 != 0) goto <D.26507>; else goto <D.26508>;
  <D.26507>:
  D.26509 = map->reg_pin_mask;
  D.26510 = encode_regmask (D.26509);
  buf.70 = buf;
  encode_uleb128 (D.26510, buf.70, &buf);
  <D.26508>:
  D.26511 = map->ncallsites;
  D.26512 = (unsigned int) D.26511;
  buf.70 = buf;
  encode_uleb128 (D.26512, buf.70, &buf);
  buf.70 = buf;
  *endbuf = buf.70;
}


encode_sleb128 (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  _Bool D.26513;
  unsigned char D.26514;
  unsigned int D.26517;
  int D.26518;
  int D.26519;
  int D.26520;
  int D.26526;
  int D.26527;
  guint8 * p.72;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;
  guint8 * p;

  more = 1;
  D.26513 = value < 0;
  negative = (gboolean) D.26513;
  size = 32;
  p = buf;
  goto <D.24775>;
  <D.24774>:
  D.26514 = (unsigned char) value;
  byte = D.26514 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.26515>; else goto <D.26516>;
  <D.26515>:
  D.26517 = size + 4294967289;
  D.26518 = (int) D.26517;
  D.26519 = 1 << D.26518;
  D.26520 = -D.26519;
  value = D.26520 | value;
  <D.26516>:
  if (value == 0) goto <D.26525>; else goto <D.26521>;
  <D.26525>:
  D.26526 = (int) byte;
  D.26527 = D.26526 & 64;
  if (D.26527 == 0) goto <D.26522>; else goto <D.26521>;
  <D.26521>:
  if (value == -1) goto <D.26528>; else goto <D.26523>;
  <D.26528>:
  D.26526 = (int) byte;
  D.26527 = D.26526 & 64;
  if (D.26527 != 0) goto <D.26522>; else goto <D.26523>;
  <D.26522>:
  more = 0;
  goto <D.26524>;
  <D.26523>:
  byte = byte | 128;
  <D.26524>:
  p.72 = p;
  p = p.72 + 1;
  *p.72 = byte;
  <D.24775>:
  if (more != 0) goto <D.24774>; else goto <D.24776>;
  <D.24776>:
  *endbuf = p;
}


encode_frame_reg (int frame_reg)
{
  int D.26532;

  if (frame_reg == 13) goto <D.26530>; else goto <D.26531>;
  <D.26530>:
  D.26532 = 0;
  return D.26532;
  <D.26531>:
  if (frame_reg == 11) goto <D.26533>; else goto <D.26534>;
  <D.26533>:
  D.26532 = 1;
  return D.26532;
  <D.26534>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-gc.c", 395);
  D.26532 = -1;
  return D.26532;
}


encode_regmask (guint32 regmask)
{
  int D.26536;
  int D.26537;
  unsigned int D.26538;
  unsigned int D.26539;
  int D.26542;
  unsigned int D.26543;
  unsigned int i.73;
  _Bool D.26545;
  long int D.26546;
  long int D.26547;
  guint32 D.26550;
  int i;
  guint32 res;

  res = 0;
  i = 0;
  goto <D.24810>;
  <D.24809>:
  D.26536 = callee_saved_regs[i];
  D.26537 = 1 << D.26536;
  D.26538 = (unsigned int) D.26537;
  D.26539 = D.26538 & regmask;
  if (D.26539 != 0) goto <D.26540>; else goto <D.26541>;
  <D.26540>:
  D.26542 = 1 << i;
  D.26543 = (unsigned int) D.26542;
  res = D.26543 | res;
  D.26536 = callee_saved_regs[i];
  D.26537 = 1 << D.26536;
  D.26538 = (unsigned int) D.26537;
  regmask = regmask - D.26538;
  <D.26541>:
  i = i + 1;
  <D.24810>:
  i.73 = (unsigned int) i;
  if (i.73 <= 6) goto <D.24809>; else goto <D.24811>;
  <D.24811>:
  D.26545 = regmask != 0;
  D.26546 = (long int) D.26545;
  D.26547 = __builtin_expect (D.26546, 0);
  if (D.26547 != 0) goto <D.26548>; else goto <D.26549>;
  <D.26548>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 456, "regmask == 0");
  <D.26549>:
  D.26550 = res;
  return D.26550;
}


encode_uleb128 (guint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned char D.26552;
  guint8 * p.74;
  guint8 * p;

  p = buf;
  <D.24762>:
  {
    guint8 b;

    D.26552 = (unsigned char) value;
    b = D.26552 & 127;
    value = value >> 7;
    if (value != 0) goto <D.26553>; else goto <D.26554>;
    <D.26553>:
    b = b | 128;
    <D.26554>:
    p.74 = p;
    p = p.74 + 1;
    *p.74 = b;
  }
  if (value != 0) goto <D.24762>; else goto <D.24763>;
  <D.24763>:
  *endbuf = p;
}


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

  D.26557 = __builtin_object_size (__dest, 0);
  D.26556 = __builtin___memcpy_chk (__dest, __src, __len, D.26557);
  return D.26556;
}


mini_gc_init ()
{
  struct FILE * logfile.75;
  struct MonoGCCallbacks cb;

  try
    {
      memset (&cb, 0, 16);
      cb.thread_attach_func = thread_attach_func;
      cb.thread_detach_func = thread_detach_func;
      cb.thread_suspend_func = thread_suspend_func;
      cb.thread_mark_func = thread_mark_func;
      mono_gc_set_gc_callbacks (&cb);
      logfile.75 = mono_gc_get_logfile ();
      logfile = logfile.75;
      parse_debug_options ();
      mono_counters_register ("GC Maps size", 512, &stats.gc_maps_size);
      mono_counters_register ("GC Call Sites size", 512, &stats.gc_callsites_size);
      mono_counters_register ("GC Bitmaps size", 512, &stats.gc_bitmaps_size);
      mono_counters_register ("GC Map struct size", 512, &stats.gc_map_struct_size);
      mono_counters_register ("GC Call Sites encoded using 8 bits", 512, &stats.gc_callsites8_size);
      mono_counters_register ("GC Call Sites encoded using 16 bits", 512, &stats.gc_callsites16_size);
      mono_counters_register ("GC Call Sites encoded using 32 bits", 512, &stats.gc_callsites32_size);
      mono_counters_register ("GC Map slots (all)", 512, &stats.all_slots);
      mono_counters_register ("GC Map slots (ref)", 512, &stats.ref_slots);
      mono_counters_register ("GC Map slots (noref)", 512, &stats.noref_slots);
      mono_counters_register ("GC Map slots (pin)", 512, &stats.pin_slots);
      mono_counters_register ("GC TLS Data size", 512, &stats.tlsdata_size);
      mono_counters_register ("Stack space scanned (all)", 512, &stats.scanned_stacks);
      mono_counters_register ("Stack space scanned (native)", 512, &stats.scanned_native);
      mono_counters_register ("Stack space scanned (other)", 512, &stats.scanned_other);
      mono_counters_register ("Stack space scanned (using GC Maps)", 512, &stats.scanned);
      mono_counters_register ("Stack space scanned (precise)", 512, &stats.scanned_precisely);
      mono_counters_register ("Stack space scanned (pin)", 512, &stats.scanned_conservatively);
      mono_counters_register ("Stack space scanned (pin registers)", 512, &stats.scanned_registers);
    }
  finally
    {
      cb = {CLOBBER};
    }
}


thread_mark_func (void * user_data, guint8 * stack_start, guint8 * stack_end, gboolean precise)
{
  struct TlsData * tls;

  tls = user_data;
  if (precise == 0) goto <D.26560>; else goto <D.26561>;
  <D.26560>:
  conservative_pass (tls, stack_start, stack_end);
  goto <D.26562>;
  <D.26561>:
  precise_pass (tls, stack_start, stack_end);
  <D.26562>:
}


conservative_pass (struct TlsData * tls, guint8 * stack_start, guint8 * stack_end)
{
  struct MonoInternalThread * D.26567;
  int D.26569;
  int stack_end.76;
  int stack_start.77;
  int D.26572;
  int D.26573;
  void * lmf.78;
  int D.26575;
  struct MonoContext * D.26579;
  mgreg_t * D.26581;
  mgreg_t * D.26584;
  void * D.26587;
  unsigned int stack_limit.79;
  unsigned int D.26589;
  _Bool D.26590;
  long int D.26591;
  long int D.26592;
  struct MonoDomain * iftmp.80;
  struct MonoDomain * D.26596;
  void * D.26600;
  <unnamed type> D.26602;
  void * D.26618;
  int D.26619;
  void * D.26620;
  int D.26621;
  unsigned char D.26622;
  unsigned char D.26623;
  int D.26626;
  _Bool D.26628;
  long int D.26629;
  long int D.26630;
  unsigned int emap.81;
  unsigned int D.26636;
  _Bool D.26637;
  long int D.26638;
  long int D.26639;
  int precise_frame_limit_inited.82;
  const gchar * D.26645;
  const gchar * D.26648;
  int precise_frame_limit.83;
  int precise_frame_limit.84;
  int D.26653;
  char * D.26656;
  int D.26659;
  guint8 * D.26660;
  unsigned char D.26661;
  int D.26662;
  int D.26663;
  guint8 * p.85;
  int p.86;
  int D.26666;
  int D.26667;
  int D.26668;
  guint8 * p.87;
  int D.26670;
  int D.26671;
  sizetype D.26672;
  guint8 * p.88;
  unsigned char D.26674;
  int D.26675;
  int D.26676;
  int D.26677;
  sizetype D.26678;
  int D.26679;
  sizetype D.26680;
  sizetype D.26681;
  int D.26682;
  sizetype D.26683;
  guint8 * D.26686;
  sizetype i.89;
  guint8 * D.26688;
  unsigned char D.26689;
  int D.26690;
  int D.26691;
  guint16 * D.26696;
  unsigned int i.90;
  unsigned int D.26698;
  guint16 * D.26699;
  short unsigned int D.26700;
  int D.26701;
  guint32 * D.26704;
  unsigned int D.26705;
  guint32 * D.26706;
  unsigned int D.26707;
  unsigned int D.26708;
  char * D.26712;
  int D.26715;
  int real_frame_start.91;
  int stack_limit.92;
  int D.26718;
  int D.26719;
  unsigned char D.26720;
  unsigned char D.26721;
  int D.26724;
  int D.26725;
  unsigned int D.26726;
  int D.26727;
  unsigned int D.26728;
  unsigned int D.26729;
  int D.26730;
  sizetype D.26731;
  guint8 * D.26732;
  unsigned char D.26733;
  int D.26734;
  int D.26735;
  int D.26736;
  void * D.26739;
  int D.26742;
  int D.26743;
  int D.26744;
  int D.26745;
  unsigned int D.26746;
  int D.26747;
  unsigned int D.26748;
  unsigned char D.26749;
  unsigned char D.26752;
  int D.26753;
  int D.26754;
  unsigned int D.26755;
  int D.26756;
  unsigned int D.26757;
  unsigned int D.26758;
  int D.26759;
  unsigned int D.26760;
  unsigned int D.26761;
  unsigned int D.26764;
  unsigned int D.26765;
  int D.26768;
  sizetype D.26769;
  guint8 * D.26770;
  unsigned char D.26771;
  int D.26772;
  int D.26773;
  int D.26774;
  int D.26775;
  int D.26778;
  unsigned int D.26779;
  int D.26780;
  _Bool D.26781;
  long int D.26782;
  long int D.26783;
  unsigned char D.26786;
  unsigned int D.26789;
  int D.26790;
  unsigned int D.26791;
  unsigned int D.26792;
  guint8 * D.26793;
  int frame_start.93;
  int D.26796;
  unsigned char D.26797;
  unsigned char D.26800;
  int D.26801;
  int D.26802;
  unsigned int D.26803;
  int D.26804;
  unsigned int D.26805;
  unsigned int D.26806;
  unsigned int D.26807;
  unsigned int D.26808;
  int D.26813;
  sizetype D.26814;
  guint8 * D.26815;
  unsigned char D.26816;
  int D.26817;
  int D.26818;
  int D.26819;
  int D.26820;
  int D.26823;
  int D.26824;
  int D.26825;
  int D.26826;
  unsigned int D.26829;
  int D.26834;
  int D.26841;
  int D.26842;
  int D.26843;
  int D.26844;
  int D.26845;
  int D.26846;
  int D.26847;
  int D.26848;
  int D.26849;
  int D.26850;
  int D.26851;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;
  struct MonoContext ctx;
  struct MonoContext new_ctx;
  struct MonoLMF * lmf;
  guint8 * stack_limit;
  gboolean last;
  struct GCMap * map;
  struct GCMap map_tmp;
  struct GCEncodedMap * emap;
  guint8 * fp;
  guint8 * p;
  guint8 * real_frame_start;
  guint8 * frame_start;
  guint8 * frame_end;
  int i;
  int pc_offset;
  int cindex;
  int bitmap_width;
  int scanned;
  int scanned_precisely;
  int scanned_conservatively;
  int scanned_registers;
  gboolean res;
  struct StackFrameInfo frame;
  mgreg_t * reg_locations[16];
  mgreg_t * new_reg_locations[16];
  guint8 * bitmaps;
  struct FrameInfo * fi;
  guint32 precise_regmask;

  try
    {
      last = 1;
      scanned = 0;
      if (tls != 0B) goto <D.26563>; else goto <D.26564>;
      <D.26563>:
      tls->nframes = 0;
      tls->ref_to_track = 0B;
      <D.26564>:
      D.26567 = mono_thread_internal_current ();
      if (D.26567 == 0B) goto <D.26565>; else goto <D.26568>;
      <D.26568>:
      if (tls == 0B) goto <D.26565>; else goto <D.26566>;
      <D.26565>:
      mono_gc_conservatively_scan_area (stack_start, stack_end);
      D.26569 = stats.scanned_stacks;
      stack_end.76 = (int) stack_end;
      stack_start.77 = (int) stack_start;
      D.26572 = stack_end.76 - stack_start.77;
      D.26573 = D.26569 + D.26572;
      stats.scanned_stacks = D.26573;
      return;
      <D.26566>:
      lmf.78 = tls->unwind_state.unwind_data[1];
      lmf = lmf.78;
      frame.domain = 0B;
      scanned = 0;
      scanned_precisely = 0;
      scanned_conservatively = 0;
      scanned_registers = 0;
      stack_limit = stack_start;
      D.26575 = tls->unwind_state.valid;
      if (D.26575 == 0) goto <D.26576>; else goto <D.26577>;
      <D.26576>:
      memset (&new_ctx, 0, 208);
      goto <D.26578>;
      <D.26577>:
      D.26579 = &tls->unwind_state.ctx;
      memcpy (&new_ctx, D.26579, 208);
      <D.26578>:
      memset (&reg_locations, 0, 64);
      memset (&new_reg_locations, 0, 64);
      <D.24969>:
      D.26575 = tls->unwind_state.valid;
      if (D.26575 == 0) goto <D.24925>; else goto <D.26580>;
      <D.26580>:
      memcpy (&ctx, &new_ctx, 208);
      i = 0;
      goto <D.24927>;
      <D.24926>:
      D.26581 = new_reg_locations[i];
      if (D.26581 != 0B) goto <D.26582>; else goto <D.26583>;
      <D.26582>:
      D.26584 = reg_locations[i];
      if (D.26584 != 0B) goto <D.26585>; else goto <D.26586>;
      <D.26585>:
      D.26584 = reg_locations[i];
      D.26584 = reg_locations[i];
      D.26587 = D.26584 + 4;
      mono_gc_conservatively_scan_area (D.26584, D.26587);
      scanned_registers = scanned_registers + 4;
      <D.26586>:
      D.26581 = new_reg_locations[i];
      reg_locations[i] = D.26581;
      <D.26583>:
      i = i + 1;
      <D.24927>:
      if (i <= 15) goto <D.24926>; else goto <D.24928>;
      <D.24928>:
      stack_limit.79 = (unsigned int) stack_limit;
      D.26589 = stack_limit.79 & 3;
      D.26590 = D.26589 != 0;
      D.26591 = (long int) D.26590;
      D.26592 = __builtin_expect (D.26591, 0);
      if (D.26592 != 0) goto <D.26593>; else goto <D.26594>;
      <D.26593>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 784, "(mgreg_t)stack_limit % SIZEOF_SLOT == 0");
      <D.26594>:
      D.26596 = frame.domain;
      if (D.26596 != 0B) goto <D.26597>; else goto <D.26598>;
      <D.26597>:
      iftmp.80 = frame.domain;
      goto <D.26599>;
      <D.26598>:
      iftmp.80 = tls->unwind_state.unwind_data[0];
      <D.26599>:
      D.26600 = tls->unwind_state.unwind_data[2];
      res = mono_find_jit_info_ext (iftmp.80, D.26600, 0B, &ctx, &new_ctx, 0B, &lmf, &new_reg_locations, &frame);
      if (res == 0) goto <D.24925>; else goto <D.26601>;
      <D.26601>:
      ji = frame.ji;
      D.26602 = frame.type;
      if (D.26602 == 2) goto <D.26603>; else goto <D.26604>;
      <D.26603>:
      i = 0;
      goto <D.24930>;
      <D.24929>:
      D.26584 = reg_locations[i];
      if (D.26584 != 0B) goto <D.26605>; else goto <D.26606>;
      <D.26605>:
      D.26584 = reg_locations[i];
      D.26584 = reg_locations[i];
      D.26587 = D.26584 + 4;
      mono_gc_conservatively_scan_area (D.26584, D.26587);
      scanned_registers = scanned_registers + 4;
      <D.26606>:
      reg_locations[i] = 0B;
      new_reg_locations[i] = 0B;
      i = i + 1;
      <D.24930>:
      if (i <= 15) goto <D.24929>; else goto <D.24931>;
      <D.24931>:
      ctx = new_ctx;
      // predicted unlikely by continue predictor.
      goto <D.24932>;
      <D.26604>:
      if (ji != 0B) goto <D.26607>; else goto <D.26608>;
      <D.26607>:
      method = jinfo_get_method (ji);
      goto <D.26609>;
      <D.26608>:
      method = 0B;
      <D.26609>:
      if (last != 0) goto <D.26610>; else goto <D.26611>;
      <D.26610>:
      if (ji != 0B) goto <D.26612>; else goto <D.26613>;
      <D.26612>:
      <D.26613>:
      last = 0;
      i = 0;
      goto <D.24934>;
      <D.24933>:
      D.26584 = reg_locations[i];
      if (D.26584 != 0B) goto <D.26614>; else goto <D.26615>;
      <D.26614>:
      D.26584 = reg_locations[i];
      D.26584 = reg_locations[i];
      D.26587 = D.26584 + 4;
      mono_gc_conservatively_scan_area (D.26584, D.26587);
      scanned_registers = scanned_registers + 4;
      <D.26615>:
      D.26581 = new_reg_locations[i];
      if (D.26581 != 0B) goto <D.26616>; else goto <D.26617>;
      <D.26616>:
      D.26581 = new_reg_locations[i];
      D.26581 = new_reg_locations[i];
      D.26618 = D.26581 + 4;
      mono_gc_conservatively_scan_area (D.26581, D.26618);
      scanned_registers = scanned_registers + 4;
      <D.26617>:
      reg_locations[i] = 0B;
      new_reg_locations[i] = 0B;
      i = i + 1;
      <D.24934>:
      if (i <= 15) goto <D.24933>; else goto <D.24935>;
      <D.24935>:
      // predicted unlikely by continue predictor.
      goto <D.24932>;
      <D.26611>:
      D.26619 = ctx.pc;
      D.26620 = ji->code_start;
      D.26621 = (int) D.26620;
      pc_offset = D.26619 - D.26621;
      D.26622 = BIT_FIELD_REF <*method, 8, 160>;
      D.26623 = D.26622 & 124;
      if (D.26623 == 24) goto <D.26624>; else goto <D.26625>;
      <D.26624>:
      // predicted unlikely by continue predictor.
      goto <D.24932>;
      <D.26625>:
      D.26626 = tls->nframes;
      if (D.26626 == 50) goto <D.24925>; else goto <D.26627>;
      <D.26627>:
      D.26628 = pc_offset < 0;
      D.26629 = (long int) D.26628;
      D.26630 = __builtin_expect (D.26629, 0);
      if (D.26630 != 0) goto <D.26631>; else goto <D.26632>;
      <D.26631>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 877, "pc_offset >= 0");
      <D.26632>:
      emap = ji->gc_info;
      if (emap == 0B) goto <D.26633>; else goto <D.26634>;
      <D.26633>:
      // predicted unlikely by continue predictor.
      goto <D.24932>;
      <D.26634>:
      emap.81 = (unsigned int) emap;
      D.26636 = emap.81 & 3;
      D.26637 = D.26636 != 0;
      D.26638 = (long int) D.26637;
      D.26639 = __builtin_expect (D.26638, 0);
      if (D.26639 != 0) goto <D.26640>; else goto <D.26641>;
      <D.26640>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 888, "((mgreg_t)emap % 4) == 0");
      <D.26641>:
      precise_frame_limit_inited.82 = precise_frame_limit_inited;
      if (precise_frame_limit_inited.82 == 0) goto <D.26643>; else goto <D.26644>;
      <D.26643>:
      D.26645 = monoeg_g_getenv ("MONO_PRECISE_COUNT");
      if (D.26645 != 0B) goto <D.26646>; else goto <D.26647>;
      <D.26646>:
      D.26648 = monoeg_g_getenv ("MONO_PRECISE_COUNT");
      precise_frame_limit.83 = atoi (D.26648);
      precise_frame_limit = precise_frame_limit.83;
      <D.26647>:
      precise_frame_limit_inited = 1;
      <D.26644>:
      precise_frame_limit.84 = precise_frame_limit;
      if (precise_frame_limit.84 != -1) goto <D.26651>; else goto <D.26652>;
      <D.26651>:
      D.26653 = precise_frame_count[0];
      precise_frame_limit.84 = precise_frame_limit;
      if (D.26653 == precise_frame_limit.84) goto <D.26654>; else goto <D.26655>;
      <D.26654>:
      D.26656 = mono_method_full_name (method, 1);
      printf ("LAST PRECISE FRAME: %s\n", D.26656);
      <D.26655>:
      D.26653 = precise_frame_count[0];
      precise_frame_limit.84 = precise_frame_limit;
      if (D.26653 > precise_frame_limit.84) goto <D.26657>; else goto <D.26658>;
      <D.26657>:
      // predicted unlikely by continue predictor.
      goto <D.24932>;
      <D.26658>:
      <D.26652>:
      D.26653 = precise_frame_count[0];
      D.26659 = D.26653 + 1;
      precise_frame_count[0] = D.26659;
      map = &map_tmp;
      memset (map, 0, 60);
      D.26660 = &emap->encoded[0];
      decode_gc_map (D.26660, map, &p);
      D.26661 = map->callsite_entry_size;
      D.26662 = (int) D.26661;
      D.26663 = D.26662 + -1;
      p.85 = p;
      p.86 = (int) p.85;
      D.26666 = D.26663 + p.86;
      D.26661 = map->callsite_entry_size;
      D.26662 = (int) D.26661;
      D.26667 = -D.26662;
      D.26668 = D.26666 & D.26667;
      p.87 = (guint8 *) D.26668;
      p = p.87;
      p.85 = p;
      map->callsites.offsets8 = p.85;
      p.85 = p;
      D.26661 = map->callsite_entry_size;
      D.26662 = (int) D.26661;
      D.26670 = map->ncallsites;
      D.26671 = D.26662 * D.26670;
      D.26672 = (sizetype) D.26671;
      p.88 = p.85 + D.26672;
      p = p.88;
      bitmaps = p;
      D.26674 = map->frame_reg;
      D.26675 = (int) D.26674;
      D.26676 = get_frame_pointer (&ctx, D.26675);
      fp = (guint8 *) D.26676;
      D.26677 = map->start_offset;
      D.26678 = (sizetype) D.26677;
      real_frame_start = fp + D.26678;
      D.26677 = map->start_offset;
      D.26678 = (sizetype) D.26677;
      D.26679 = map->map_offset;
      D.26680 = (sizetype) D.26679;
      D.26681 = D.26678 + D.26680;
      frame_start = fp + D.26681;
      D.26682 = map->end_offset;
      D.26683 = (sizetype) D.26682;
      frame_end = fp + D.26683;
      D.26661 = map->callsite_entry_size;
      if (D.26661 == 1) goto <D.26684>; else goto <D.26685>;
      <D.26684>:
      i = 0;
      goto <D.24938>;
      <D.24937>:
      D.26686 = map->callsites.offsets8;
      i.89 = (sizetype) i;
      D.26688 = D.26686 + i.89;
      D.26689 = *D.26688;
      D.26690 = (int) D.26689;
      D.26691 = pc_offset + 1;
      if (D.26690 == D.26691) goto <D.24936>; else goto <D.26692>;
      <D.26692>:
      i = i + 1;
      <D.24938>:
      D.26670 = map->ncallsites;
      if (D.26670 > i) goto <D.24937>; else goto <D.24936>;
      <D.24936>:
      goto <D.26693>;
      <D.26685>:
      D.26661 = map->callsite_entry_size;
      if (D.26661 == 2) goto <D.26694>; else goto <D.26695>;
      <D.26694>:
      i = 0;
      goto <D.24941>;
      <D.24940>:
      D.26696 = map->callsites.offsets16;
      i.90 = (unsigned int) i;
      D.26698 = i.90 * 2;
      D.26699 = D.26696 + D.26698;
      D.26700 = *D.26699;
      D.26701 = (int) D.26700;
      D.26691 = pc_offset + 1;
      if (D.26701 == D.26691) goto <D.24939>; else goto <D.26702>;
      <D.26702>:
      i = i + 1;
      <D.24941>:
      D.26670 = map->ncallsites;
      if (D.26670 > i) goto <D.24940>; else goto <D.24939>;
      <D.24939>:
      goto <D.26703>;
      <D.26695>:
      i = 0;
      goto <D.24944>;
      <D.24943>:
      D.26704 = map->callsites.offsets32;
      i.90 = (unsigned int) i;
      D.26705 = i.90 * 4;
      D.26706 = D.26704 + D.26705;
      D.26707 = *D.26706;
      D.26691 = pc_offset + 1;
      D.26708 = (unsigned int) D.26691;
      if (D.26707 == D.26708) goto <D.24942>; else goto <D.26709>;
      <D.26709>:
      i = i + 1;
      <D.24944>:
      D.26670 = map->ncallsites;
      if (D.26670 > i) goto <D.24943>; else goto <D.24942>;
      <D.24942>:
      <D.26703>:
      <D.26693>:
      D.26670 = map->ncallsites;
      if (D.26670 == i) goto <D.26710>; else goto <D.26711>;
      <D.26710>:
      D.26691 = pc_offset + 1;
      D.26712 = mono_method_full_name (method, 1);
      printf ("Unable to find ip offset 0x%x in callsite list of %s.\n", D.26691, D.26712);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-gc.c", 945);
      <D.26711>:
      cindex = i;
      if (real_frame_start > stack_limit) goto <D.26713>; else goto <D.26714>;
      <D.26713>:
      mono_gc_conservatively_scan_area (stack_limit, real_frame_start);
      D.26715 = stats.scanned_other;
      real_frame_start.91 = (int) real_frame_start;
      stack_limit.92 = (int) stack_limit;
      D.26718 = real_frame_start.91 - stack_limit.92;
      D.26719 = D.26715 + D.26718;
      stats.scanned_other = D.26719;
      <D.26714>:
      D.26720 = BIT_FIELD_REF <*map, 8, 144>;
      D.26721 = D.26720 & 1;
      if (D.26721 != 0) goto <D.26722>; else goto <D.26723>;
      <D.26722>:
      {
        int bitmap_width;
        guint8 * pin_bitmap;
        guint8 * p;
        gboolean pinned;

        D.26724 = map->nslots;
        D.26725 = D.26724 + 7;
        bitmap_width = D.26725 >> 3;
        D.26726 = map->stack_pin_bitmap_offset;
        D.26727 = bitmap_width * cindex;
        D.26728 = (unsigned int) D.26727;
        D.26729 = D.26726 + D.26728;
        pin_bitmap = bitmaps + D.26729;
        p = frame_start;
        i = 0;
        goto <D.24950>;
        <D.24949>:
        D.26730 = i / 8;
        D.26731 = (sizetype) D.26730;
        D.26732 = pin_bitmap + D.26731;
        D.26733 = *D.26732;
        D.26734 = (int) D.26733;
        D.26735 = i % 8;
        D.26736 = 1 << D.26735;
        pinned = D.26734 & D.26736;
        if (pinned != 0) goto <D.26737>; else goto <D.26738>;
        <D.26737>:
        D.26739 = p + 4;
        mono_gc_conservatively_scan_area (p, D.26739);
        scanned_conservatively = scanned_conservatively + 4;
        goto <D.26740>;
        <D.26738>:
        scanned_precisely = scanned_precisely + 4;
        <D.26740>:
        p = p + 4;
        i = i + 1;
        <D.24950>:
        D.26724 = map->nslots;
        if (D.26724 > i) goto <D.24949>; else goto <D.24951>;
        <D.24951>:
      }
      goto <D.26741>;
      <D.26723>:
      D.26724 = map->nslots;
      D.26742 = D.26724 * 4;
      scanned_precisely = D.26742 + scanned_precisely;
      <D.26741>:
      D.26682 = map->end_offset;
      D.26677 = map->start_offset;
      D.26743 = D.26682 - D.26677;
      D.26724 = map->nslots;
      D.26744 = D.26724 * -4;
      D.26745 = D.26743 + D.26744;
      scanned_precisely = D.26745 + scanned_precisely;
      D.26746 = map->used_int_regs;
      D.26674 = map->frame_reg;
      D.26675 = (int) D.26674;
      D.26747 = 1 << D.26675;
      D.26748 = (unsigned int) D.26747;
      precise_regmask = D.26746 | D.26748;
      D.26720 = BIT_FIELD_REF <*map, 8, 144>;
      D.26749 = D.26720 & 8;
      if (D.26749 != 0) goto <D.26750>; else goto <D.26751>;
      <D.26750>:
      {
        int bitmap_width;
        guint8 * pin_bitmap;
        int bindex;

        D.26752 = map->npin_regs;
        D.26753 = (int) D.26752;
        D.26754 = D.26753 + 7;
        bitmap_width = D.26754 >> 3;
        D.26755 = map->reg_pin_bitmap_offset;
        D.26756 = bitmap_width * cindex;
        D.26757 = (unsigned int) D.26756;
        D.26758 = D.26755 + D.26757;
        pin_bitmap = bitmaps + D.26758;
        bindex = 0;
        i = 0;
        goto <D.24957>;
        <D.24956>:
        D.26746 = map->used_int_regs;
        D.26759 = 1 << i;
        D.26760 = (unsigned int) D.26759;
        D.26761 = D.26746 & D.26760;
        if (D.26761 == 0) goto <D.26762>; else goto <D.26763>;
        <D.26762>:
        // predicted unlikely by continue predictor.
        goto <D.24955>;
        <D.26763>:
        D.26764 = map->reg_pin_mask;
        D.26759 = 1 << i;
        D.26760 = (unsigned int) D.26759;
        D.26765 = D.26764 & D.26760;
        if (D.26765 == 0) goto <D.26766>; else goto <D.26767>;
        <D.26766>:
        // predicted unlikely by continue predictor.
        goto <D.24955>;
        <D.26767>:
        D.26768 = bindex / 8;
        D.26769 = (sizetype) D.26768;
        D.26770 = pin_bitmap + D.26769;
        D.26771 = *D.26770;
        D.26772 = (int) D.26771;
        D.26773 = bindex % 8;
        D.26774 = D.26772 >> D.26773;
        D.26775 = D.26774 & 1;
        if (D.26775 != 0) goto <D.26776>; else goto <D.26777>;
        <D.26776>:
        D.26759 = 1 << i;
        D.26778 = ~D.26759;
        D.26779 = (unsigned int) D.26778;
        precise_regmask = D.26779 & precise_regmask;
        <D.26777>:
        bindex = bindex + 1;
        <D.24955>:
        i = i + 1;
        <D.24957>:
        if (i <= 15) goto <D.24956>; else goto <D.24958>;
        <D.24958>:
      }
      <D.26751>:
      D.26682 = map->end_offset;
      D.26677 = map->start_offset;
      D.26743 = D.26682 - D.26677;
      scanned = D.26743 + scanned;
      D.26780 = scanned_precisely + scanned_conservatively;
      D.26781 = D.26780 != scanned;
      D.26782 = (long int) D.26781;
      D.26783 = __builtin_expect (D.26782, 0);
      if (D.26783 != 0) goto <D.26784>; else goto <D.26785>;
      <D.26784>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 1011, "scanned == scanned_precisely + scanned_conservatively");
      <D.26785>:
      stack_limit = frame_end;
      D.26626 = tls->nframes;
      fi = &tls->frames[D.26626];
      D.26724 = map->nslots;
      fi->nslots = D.26724;
      D.26724 = map->nslots;
      D.26725 = D.26724 + 7;
      bitmap_width = D.26725 >> 3;
      D.26720 = BIT_FIELD_REF <*map, 8, 144>;
      D.26786 = D.26720 & 2;
      if (D.26786 != 0) goto <D.26787>; else goto <D.26788>;
      <D.26787>:
      D.26789 = map->stack_ref_bitmap_offset;
      D.26790 = bitmap_width * cindex;
      D.26791 = (unsigned int) D.26790;
      D.26792 = D.26789 + D.26791;
      D.26793 = bitmaps + D.26792;
      fi->bitmap = D.26793;
      goto <D.26794>;
      <D.26788>:
      fi->bitmap = 0B;
      <D.26794>:
      frame_start.93 = (int) frame_start;
      stack_start.77 = (int) stack_start;
      D.26796 = frame_start.93 - stack_start.77;
      fi->frame_start_offset = D.26796;
      fi->nreg_locations = 0;
      D.26720 = BIT_FIELD_REF <*map, 8, 144>;
      D.26797 = D.26720 & 4;
      if (D.26797 != 0) goto <D.26798>; else goto <D.26799>;
      <D.26798>:
      {
        int bitmap_width;
        guint8 * ref_bitmap;
        int bindex;

        D.26800 = map->nref_regs;
        D.26801 = (int) D.26800;
        D.26802 = D.26801 + 7;
        bitmap_width = D.26802 >> 3;
        D.26803 = map->reg_ref_bitmap_offset;
        D.26804 = bitmap_width * cindex;
        D.26805 = (unsigned int) D.26804;
        D.26806 = D.26803 + D.26805;
        ref_bitmap = bitmaps + D.26806;
        bindex = 0;
        i = 0;
        goto <D.24964>;
        <D.24963>:
        D.26807 = map->reg_ref_mask;
        D.26759 = 1 << i;
        D.26760 = (unsigned int) D.26759;
        D.26808 = D.26807 & D.26760;
        if (D.26808 == 0) goto <D.26809>; else goto <D.26810>;
        <D.26809>:
        // predicted unlikely by continue predictor.
        goto <D.24962>;
        <D.26810>:
        D.26584 = reg_locations[i];
        if (D.26584 != 0B) goto <D.26811>; else goto <D.26812>;
        <D.26811>:
        D.26813 = bindex / 8;
        D.26814 = (sizetype) D.26813;
        D.26815 = ref_bitmap + D.26814;
        D.26816 = *D.26815;
        D.26817 = (int) D.26816;
        D.26818 = bindex % 8;
        D.26819 = D.26817 >> D.26818;
        D.26820 = D.26819 & 1;
        if (D.26820 != 0) goto <D.26821>; else goto <D.26822>;
        <D.26821>:
        D.26823 = fi->nreg_locations;
        D.26584 = reg_locations[i];
        D.26824 = (int) D.26584;
        stack_start.77 = (int) stack_start;
        D.26825 = D.26824 - stack_start.77;
        fi->reg_locations[D.26823] = D.26825;
        D.26823 = fi->nreg_locations;
        D.26826 = D.26823 + 1;
        fi->nreg_locations = D.26826;
        <D.26822>:
        <D.26812>:
        bindex = bindex + 1;
        <D.24962>:
        i = i + 1;
        <D.24964>:
        if (i <= 15) goto <D.24963>; else goto <D.24965>;
        <D.24965>:
      }
      <D.26799>:
      if (precise_regmask != 0) goto <D.26827>; else goto <D.26828>;
      <D.26827>:
      i = 0;
      goto <D.24967>;
      <D.24966>:
      D.26759 = 1 << i;
      D.26760 = (unsigned int) D.26759;
      D.26829 = D.26760 & precise_regmask;
      if (D.26829 != 0) goto <D.26830>; else goto <D.26831>;
      <D.26830>:
      D.26584 = reg_locations[i];
      if (D.26584 != 0B) goto <D.26832>; else goto <D.26833>;
      <D.26832>:
      <D.26833>:
      reg_locations[i] = 0B;
      <D.26831>:
      i = i + 1;
      <D.24967>:
      if (i <= 15) goto <D.24966>; else goto <D.24968>;
      <D.24968>:
      <D.26828>:
      D.26626 = tls->nframes;
      D.26834 = D.26626 + 1;
      tls->nframes = D.26834;
      <D.24932>:
      goto <D.24969>;
      <D.24925>:
      i = 0;
      goto <D.24971>;
      <D.24970>:
      D.26584 = reg_locations[i];
      if (D.26584 != 0B) goto <D.26835>; else goto <D.26836>;
      <D.26835>:
      D.26584 = reg_locations[i];
      D.26584 = reg_locations[i];
      D.26587 = D.26584 + 4;
      mono_gc_conservatively_scan_area (D.26584, D.26587);
      scanned_registers = scanned_registers + 4;
      <D.26836>:
      D.26581 = new_reg_locations[i];
      if (D.26581 != 0B) goto <D.26837>; else goto <D.26838>;
      <D.26837>:
      D.26581 = new_reg_locations[i];
      D.26581 = new_reg_locations[i];
      D.26618 = D.26581 + 4;
      mono_gc_conservatively_scan_area (D.26581, D.26618);
      scanned_registers = scanned_registers + 4;
      <D.26838>:
      i = i + 1;
      <D.24971>:
      if (i <= 15) goto <D.24970>; else goto <D.24972>;
      <D.24972>:
      if (stack_limit < stack_end) goto <D.26839>; else goto <D.26840>;
      <D.26839>:
      mono_gc_conservatively_scan_area (stack_limit, stack_end);
      D.26841 = stats.scanned_native;
      stack_end.76 = (int) stack_end;
      stack_limit.92 = (int) stack_limit;
      D.26842 = stack_end.76 - stack_limit.92;
      D.26843 = D.26841 + D.26842;
      stats.scanned_native = D.26843;
      <D.26840>:
      D.26569 = stats.scanned_stacks;
      stack_end.76 = (int) stack_end;
      stack_start.77 = (int) stack_start;
      D.26572 = stack_end.76 - stack_start.77;
      D.26573 = D.26569 + D.26572;
      stats.scanned_stacks = D.26573;
      D.26844 = stats.scanned;
      D.26845 = D.26844 + scanned;
      stats.scanned = D.26845;
      D.26846 = stats.scanned_precisely;
      D.26847 = D.26846 + scanned_precisely;
      stats.scanned_precisely = D.26847;
      D.26848 = stats.scanned_conservatively;
      D.26849 = D.26848 + scanned_conservatively;
      stats.scanned_conservatively = D.26849;
      D.26850 = stats.scanned_registers;
      D.26851 = D.26850 + scanned_registers;
      stats.scanned_registers = D.26851;
    }
  finally
    {
      ctx = {CLOBBER};
      new_ctx = {CLOBBER};
      lmf = {CLOBBER};
      map_tmp = {CLOBBER};
      p = {CLOBBER};
      frame = {CLOBBER};
      reg_locations = {CLOBBER};
      new_reg_locations = {CLOBBER};
    }
}


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

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


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

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


decode_gc_map (guint8 * buf, struct GCMap * map, guint8 * * endbuf)
{
  guint8 * buf.94;
  int D.26860;
  int D.26861;
  int D.26862;
  int D.26863;
  int D.26864;
  int D.26865;
  unsigned int D.26866;
  int D.26867;
  unsigned int D.26868;
  _Bool D.26869;
  unsigned int D.26870;
  _Bool D.26871;
  unsigned int D.26872;
  _Bool D.26873;
  unsigned int D.26874;
  _Bool D.26875;
  unsigned int D.26876;
  unsigned char D.26877;
  unsigned char D.26878;
  unsigned char D.26879;
  unsigned int D.26880;
  int D.26881;
  unsigned char D.26882;
  unsigned int D.26883;
  unsigned int D.26884;
  unsigned char D.26885;
  unsigned char D.26886;
  unsigned int D.26889;
  unsigned int D.26890;
  unsigned int D.26891;
  int D.26892;
  unsigned int D.26893;
  unsigned int D.26894;
  unsigned char D.26897;
  unsigned char D.26898;
  unsigned int D.26901;
  unsigned int D.26902;
  unsigned int D.26903;
  unsigned int D.26904;
  unsigned int D.26907;
  int D.26908;
  int D.26909;
  int D.26910;
  int D.26911;
  int D.26912;
  unsigned char D.26913;
  int D.26914;
  int D.26915;
  int D.26916;
  unsigned char D.26917;
  int D.26918;
  int D.26919;
  int D.26920;
  unsigned int offset.95;
  unsigned char D.26922;
  unsigned char D.26925;
  guint32 flags;
  int stack_bitmap_size;
  int reg_ref_bitmap_size;
  int reg_pin_bitmap_size;
  int offset;
  int freg;
  int i;
  int n;

  buf.94 = buf;
  D.26860 = decode_sleb128 (buf.94, &buf);
  D.26861 = D.26860 * 4;
  map->start_offset = D.26861;
  buf.94 = buf;
  D.26862 = decode_sleb128 (buf.94, &buf);
  D.26863 = D.26862 * 4;
  map->end_offset = D.26863;
  buf.94 = buf;
  D.26864 = decode_sleb128 (buf.94, &buf);
  D.26865 = D.26864 * 4;
  map->map_offset = D.26865;
  buf.94 = buf;
  D.26866 = decode_uleb128 (buf.94, &buf);
  D.26867 = (int) D.26866;
  map->nslots = D.26867;
  buf.94 = buf;
  flags = decode_uleb128 (buf.94, &buf);
  D.26868 = flags & 1;
  D.26869 = D.26868 != 0;
  map->has_ref_slots = D.26869;
  D.26870 = flags & 2;
  D.26871 = D.26870 != 0;
  map->has_pin_slots = D.26871;
  D.26872 = flags & 4;
  D.26873 = D.26872 != 0;
  map->has_ref_regs = D.26873;
  D.26874 = flags & 8;
  D.26875 = D.26874 != 0;
  map->has_pin_regs = D.26875;
  D.26876 = flags >> 4;
  D.26877 = (unsigned char) D.26876;
  D.26878 = D.26877 & 3;
  D.26879 = D.26878 + 1;
  map->callsite_entry_size = D.26879;
  D.26880 = flags >> 6;
  freg = (int) D.26880;
  D.26881 = decode_frame_reg (freg);
  D.26882 = (unsigned char) D.26881;
  map->frame_reg = D.26882;
  buf.94 = buf;
  D.26883 = decode_uleb128 (buf.94, &buf);
  D.26884 = decode_regmask (D.26883);
  map->used_int_regs = D.26884;
  D.26885 = BIT_FIELD_REF <*map, 8, 144>;
  D.26886 = D.26885 & 4;
  if (D.26886 != 0) goto <D.26887>; else goto <D.26888>;
  <D.26887>:
  buf.94 = buf;
  D.26889 = decode_uleb128 (buf.94, &buf);
  D.26890 = decode_regmask (D.26889);
  map->reg_ref_mask = D.26890;
  n = 0;
  i = 0;
  goto <D.24841>;
  <D.24840>:
  D.26891 = map->reg_ref_mask;
  D.26892 = 1 << i;
  D.26893 = (unsigned int) D.26892;
  D.26894 = D.26891 & D.26893;
  if (D.26894 != 0) goto <D.26895>; else goto <D.26896>;
  <D.26895>:
  n = n + 1;
  <D.26896>:
  i = i + 1;
  <D.24841>:
  if (i <= 15) goto <D.24840>; else goto <D.24842>;
  <D.24842>:
  D.26897 = (unsigned char) n;
  map->nref_regs = D.26897;
  <D.26888>:
  D.26885 = BIT_FIELD_REF <*map, 8, 144>;
  D.26898 = D.26885 & 8;
  if (D.26898 != 0) goto <D.26899>; else goto <D.26900>;
  <D.26899>:
  buf.94 = buf;
  D.26901 = decode_uleb128 (buf.94, &buf);
  D.26902 = decode_regmask (D.26901);
  map->reg_pin_mask = D.26902;
  n = 0;
  i = 0;
  goto <D.24844>;
  <D.24843>:
  D.26903 = map->reg_pin_mask;
  D.26892 = 1 << i;
  D.26893 = (unsigned int) D.26892;
  D.26904 = D.26903 & D.26893;
  if (D.26904 != 0) goto <D.26905>; else goto <D.26906>;
  <D.26905>:
  n = n + 1;
  <D.26906>:
  i = i + 1;
  <D.24844>:
  if (i <= 15) goto <D.24843>; else goto <D.24845>;
  <D.24845>:
  D.26897 = (unsigned char) n;
  map->npin_regs = D.26897;
  <D.26900>:
  buf.94 = buf;
  D.26907 = decode_uleb128 (buf.94, &buf);
  D.26908 = (int) D.26907;
  map->ncallsites = D.26908;
  D.26909 = map->nslots;
  D.26910 = D.26909 + 7;
  D.26911 = D.26910 >> 3;
  D.26912 = map->ncallsites;
  stack_bitmap_size = D.26911 * D.26912;
  D.26913 = map->nref_regs;
  D.26914 = (int) D.26913;
  D.26915 = D.26914 + 7;
  D.26916 = D.26915 >> 3;
  D.26912 = map->ncallsites;
  reg_ref_bitmap_size = D.26916 * D.26912;
  D.26917 = map->npin_regs;
  D.26918 = (int) D.26917;
  D.26919 = D.26918 + 7;
  D.26920 = D.26919 >> 3;
  D.26912 = map->ncallsites;
  reg_pin_bitmap_size = D.26920 * D.26912;
  offset = 0;
  offset.95 = (unsigned int) offset;
  map->stack_ref_bitmap_offset = offset.95;
  D.26885 = BIT_FIELD_REF <*map, 8, 144>;
  D.26922 = D.26885 & 2;
  if (D.26922 != 0) goto <D.26923>; else goto <D.26924>;
  <D.26923>:
  offset = offset + stack_bitmap_size;
  <D.26924>:
  offset.95 = (unsigned int) offset;
  map->stack_pin_bitmap_offset = offset.95;
  D.26885 = BIT_FIELD_REF <*map, 8, 144>;
  D.26925 = D.26885 & 1;
  if (D.26925 != 0) goto <D.26926>; else goto <D.26927>;
  <D.26926>:
  offset = offset + stack_bitmap_size;
  <D.26927>:
  offset.95 = (unsigned int) offset;
  map->reg_ref_bitmap_offset = offset.95;
  D.26885 = BIT_FIELD_REF <*map, 8, 144>;
  D.26886 = D.26885 & 4;
  if (D.26886 != 0) goto <D.26928>; else goto <D.26929>;
  <D.26928>:
  offset = offset + reg_ref_bitmap_size;
  <D.26929>:
  offset.95 = (unsigned int) offset;
  map->reg_pin_bitmap_offset = offset.95;
  D.26885 = BIT_FIELD_REF <*map, 8, 144>;
  D.26898 = D.26885 & 8;
  if (D.26898 != 0) goto <D.26930>; else goto <D.26931>;
  <D.26930>:
  offset = offset + reg_pin_bitmap_size;
  <D.26931>:
  buf.94 = buf;
  *endbuf = buf.94;
}


decode_sleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.26932;
  int D.26933;
  int D.26934;
  signed char b.96;
  int D.26940;
  int D.26943;
  int D.26944;
  gint32 D.26945;
  guint8 * p;
  gint32 res;
  int shift;

  p = buf;
  res = 0;
  shift = 0;
  <D.24796>:
  {
    guint8 b;

    b = *p;
    p = p + 1;
    D.26932 = (int) b;
    D.26933 = D.26932 & 127;
    D.26934 = D.26933 << shift;
    res = D.26934 | res;
    shift = shift + 7;
    b.96 = (signed char) b;
    if (b.96 >= 0) goto <D.26936>; else goto <D.26937>;
    <D.26936>:
    if (shift <= 31) goto <D.26938>; else goto <D.26939>;
    <D.26938>:
    D.26932 = (int) b;
    D.26940 = D.26932 & 64;
    if (D.26940 != 0) goto <D.26941>; else goto <D.26942>;
    <D.26941>:
    D.26943 = 1 << shift;
    D.26944 = -D.26943;
    res = D.26944 | res;
    <D.26942>:
    <D.26939>:
    goto <D.24795>;
    <D.26937>:
  }
  goto <D.24796>;
  <D.24795>:
  *endbuf = p;
  D.26945 = res;
  return D.26945;
}


decode_frame_reg (int encoded)
{
  int D.26949;

  if (encoded == 0) goto <D.26947>; else goto <D.26948>;
  <D.26947>:
  D.26949 = 13;
  return D.26949;
  <D.26948>:
  if (encoded == 1) goto <D.26950>; else goto <D.26951>;
  <D.26950>:
  D.26949 = 11;
  return D.26949;
  <D.26951>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-gc.c", 425);
  D.26949 = -1;
  return D.26949;
}


decode_regmask (guint32 regmask)
{
  int D.26953;
  unsigned int D.26954;
  unsigned int D.26955;
  int D.26958;
  int D.26959;
  unsigned int D.26960;
  unsigned int i.97;
  guint32 D.26962;
  int i;
  guint32 res;

  res = 0;
  i = 0;
  goto <D.24818>;
  <D.24817>:
  D.26953 = 1 << i;
  D.26954 = (unsigned int) D.26953;
  D.26955 = D.26954 & regmask;
  if (D.26955 != 0) goto <D.26956>; else goto <D.26957>;
  <D.26956>:
  D.26958 = callee_saved_regs[i];
  D.26959 = 1 << D.26958;
  D.26960 = (unsigned int) D.26959;
  res = D.26960 | res;
  <D.26957>:
  i = i + 1;
  <D.24818>:
  i.97 = (unsigned int) i;
  if (i.97 <= 6) goto <D.24817>; else goto <D.24819>;
  <D.24819>:
  D.26962 = res;
  return D.26962;
}


decode_uleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.26964;
  int D.26965;
  int D.26966;
  unsigned int D.26967;
  signed char b.98;
  guint32 D.26970;
  guint8 * p;
  guint32 res;
  int shift;

  p = buf;
  res = 0;
  shift = 0;
  <D.24786>:
  {
    guint8 b;

    b = *p;
    p = p + 1;
    D.26964 = (int) b;
    D.26965 = D.26964 & 127;
    D.26966 = D.26965 << shift;
    D.26967 = (unsigned int) D.26966;
    res = D.26967 | res;
    b.98 = (signed char) b;
    if (b.98 >= 0) goto <D.24785>; else goto <D.26969>;
    <D.26969>:
    shift = shift + 7;
  }
  goto <D.24786>;
  <D.24785>:
  *endbuf = p;
  D.26970 = res;
  return D.26970;
}


get_frame_pointer (struct MonoContext * ctx, int frame_reg)
{
  mgreg_t D.26974;

  if (frame_reg == 13) goto <D.26972>; else goto <D.26973>;
  <D.26972>:
  D.26974 = ctx->regs[13];
  return D.26974;
  <D.26973>:
  if (frame_reg == 11) goto <D.26975>; else goto <D.26976>;
  <D.26975>:
  D.26974 = ctx->regs[11];
  return D.26974;
  <D.26976>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-gc.c", 692);
  D.26974 = 0;
  return D.26974;
}


precise_pass (struct TlsData * tls, guint8 * stack_start, guint8 * stack_end)
{
  int D.26980;
  int D.26983;
  sizetype D.26984;
  guint8 * D.26985;
  int D.26988;
  sizetype D.26989;
  int D.26990;
  sizetype D.26991;
  guint8 * D.26992;
  unsigned char D.26993;
  int D.26994;
  int D.26995;
  int D.26996;
  void * D.27001;
  int D.27004;
  int D.27005;
  sizetype D.27006;
  void * D.27009;
  int D.27011;
  int D.27012;
  void * D.27013;
  int D.27016;
  int D.27017;
  int findex;
  int i;
  struct FrameInfo * fi;
  guint8 * frame_start;

  if (tls == 0B) goto <D.26978>; else goto <D.26979>;
  <D.26978>:
  return;
  <D.26979>:
  D.26980 = tls->unwind_state.valid;
  if (D.26980 == 0) goto <D.26981>; else goto <D.26982>;
  <D.26981>:
  return;
  <D.26982>:
  findex = 0;
  goto <D.24995>;
  <D.24994>:
  fi = &tls->frames[findex];
  D.26983 = fi->frame_start_offset;
  D.26984 = (sizetype) D.26983;
  frame_start = stack_start + D.26984;
  D.26985 = fi->bitmap;
  if (D.26985 != 0B) goto <D.26986>; else goto <D.26987>;
  <D.26986>:
  {
    guint8 * ref_bitmap;
    gboolean live;

    ref_bitmap = fi->bitmap;
    i = 0;
    goto <D.24987>;
    <D.24986>:
    {
      struct MonoObject * * ptr;

      D.26988 = i * 4;
      D.26989 = (sizetype) D.26988;
      ptr = frame_start + D.26989;
      D.26990 = i / 8;
      D.26991 = (sizetype) D.26990;
      D.26992 = ref_bitmap + D.26991;
      D.26993 = *D.26992;
      D.26994 = (int) D.26993;
      D.26995 = i % 8;
      D.26996 = 1 << D.26995;
      live = D.26994 & D.26996;
      if (live != 0) goto <D.26997>; else goto <D.26998>;
      <D.26997>:
      {
        struct MonoObject * obj;

        obj = *ptr;
        if (obj != 0B) goto <D.26999>; else goto <D.27000>;
        <D.26999>:
        D.27001 = mono_gc_scan_object (obj);
        *ptr = D.27001;
        goto <D.27002>;
        <D.27000>:
        <D.27002>:
      }
      goto <D.27003>;
      <D.26998>:
      <D.27003>:
    }
    i = i + 1;
    <D.24987>:
    D.27004 = fi->nslots;
    if (D.27004 > i) goto <D.24986>; else goto <D.24988>;
    <D.24988>:
  }
  <D.26987>:
  i = 0;
  goto <D.24992>;
  <D.24991>:
  {
    struct MonoObject * * ptr;
    struct MonoObject * obj;

    D.27005 = fi->reg_locations[i];
    D.27006 = (sizetype) D.27005;
    ptr = stack_start + D.27006;
    obj = *ptr;
    if (obj != 0B) goto <D.27007>; else goto <D.27008>;
    <D.27007>:
    D.27009 = mono_gc_scan_object (obj);
    *ptr = D.27009;
    goto <D.27010>;
    <D.27008>:
    <D.27010>:
  }
  i = i + 1;
  <D.24992>:
  D.27011 = fi->nreg_locations;
  if (D.27011 > i) goto <D.24991>; else goto <D.24993>;
  <D.24993>:
  findex = findex + 1;
  <D.24995>:
  D.27012 = tls->nframes;
  if (D.27012 > findex) goto <D.24994>; else goto <D.24996>;
  <D.24996>:
  D.27013 = tls->ref_to_track;
  if (D.27013 != 0B) goto <D.27014>; else goto <D.27015>;
  <D.27014>:
  {
    mgreg_t * p;

    p = stack_start;
    goto <D.24999>;
    <D.24998>:
    D.27016 = *p;
    D.27013 = tls->ref_to_track;
    D.27017 = (int) D.27013;
    if (D.27016 == D.27017) goto <D.27018>; else goto <D.27019>;
    <D.27018>:
    printf ("REF AT %p.\n", p);
    <D.27019>:
    p = p + 4;
    <D.24999>:
    if (p < stack_end) goto <D.24998>; else goto <D.25000>;
    <D.25000>:
  }
  <D.27015>:
}


thread_suspend_func (void * user_data, void * sigctx, struct MonoContext * ctx)
{
  int D.27023;
  unsigned int D.27024;
  unsigned int D.27025;
  struct MonoThreadInfo * D.27028;
  _Bool D.27029;
  long int D.27030;
  long int D.27031;
  struct MonoThreadUnwindState * D.27034;
  long unsigned int D.27035;
  int D.27036;
  struct MonoLMF * D.27038;
  struct MonoContext * D.27041;
  unsigned int mono_jit_tls_id.99;
  void * D.27047;
  struct MonoDomain * D.27048;
  void * D.27049;
  struct TlsData * tls;

  tls = user_data;
  if (tls == 0B) goto <D.27021>; else goto <D.27022>;
  <D.27021>:
  return;
  <D.27022>:
  D.27023 = tls->tid;
  D.27024 = (unsigned int) D.27023;
  D.27025 = GetCurrentThreadId ();
  if (D.27024 != D.27025) goto <D.27026>; else goto <D.27027>;
  <D.27026>:
  {
    gboolean res;

    D.27028 = tls->info;
    D.27029 = D.27028 == 0B;
    D.27030 = (long int) D.27029;
    D.27031 = __builtin_expect (D.27030, 0);
    if (D.27031 != 0) goto <D.27032>; else goto <D.27033>;
    <D.27032>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-gc.c", 600, "tls->info");
    <D.27033>:
    D.27034 = &tls->unwind_state;
    D.27023 = tls->tid;
    D.27035 = (long unsigned int) D.27023;
    D.27028 = tls->info;
    D.27036 = D.27028->native_handle;
    res = mono_thread_state_init_from_handle (D.27034, D.27035, D.27036);
  }
  goto <D.27037>;
  <D.27027>:
  D.27038 = mono_get_lmf ();
  tls->unwind_state.unwind_data[1] = D.27038;
  if (sigctx != 0B) goto <D.27039>; else goto <D.27040>;
  <D.27039>:
  D.27041 = &tls->unwind_state.ctx;
  mono_arch_sigctx_to_monoctx (sigctx, D.27041);
  tls->unwind_state.valid = 1;
  goto <D.27042>;
  <D.27040>:
  if (ctx != 0B) goto <D.27043>; else goto <D.27044>;
  <D.27043>:
  D.27041 = &tls->unwind_state.ctx;
  memcpy (D.27041, ctx, 208);
  tls->unwind_state.valid = 1;
  goto <D.27045>;
  <D.27044>:
  tls->unwind_state.valid = 0;
  <D.27045>:
  <D.27042>:
  mono_jit_tls_id.99 = mono_jit_tls_id;
  D.27047 = pthread_getspecific (mono_jit_tls_id.99);
  tls->unwind_state.unwind_data[2] = D.27047;
  D.27048 = mono_domain_get ();
  tls->unwind_state.unwind_data[0] = D.27048;
  <D.27037>:
  D.27049 = tls->unwind_state.unwind_data[0];
  if (D.27049 == 0B) goto <D.27050>; else goto <D.27051>;
  <D.27050>:
  tls->unwind_state.valid = 0;
  return;
  <D.27051>:
}


thread_detach_func (void * user_data)
{
  struct TlsData * tls;

  tls = user_data;
  monoeg_g_free (tls);
}


thread_attach_func ()
{
  unsigned int D.27053;
  int D.27054;
  struct MonoThreadInfo * D.27055;
  int D.27056;
  unsigned int D.27057;
  unsigned int D.27058;
  int D.27059;
  void * D.27060;
  struct TlsData * tls;

  tls = monoeg_malloc0 (4240);
  D.27053 = GetCurrentThreadId ();
  D.27054 = (int) D.27053;
  tls->tid = D.27054;
  D.27055 = mono_thread_info_current ();
  tls->info = D.27055;
  D.27056 = stats.tlsdata_size;
  D.27057 = (unsigned int) D.27056;
  D.27058 = D.27057 + 4240;
  D.27059 = (int) D.27058;
  stats.tlsdata_size = D.27059;
  D.27060 = tls;
  return D.27060;
}


parse_debug_options ()
{
  struct _IO_FILE * stderr.100;
  char * D.27066;
  char * * opts;
  char * * ptr;
  const char * env;

  env = monoeg_g_getenv ("MONO_GCMAP_DEBUG");
  if (env == 0B) goto <D.27062>; else goto <D.27063>;
  <D.27062>:
  return;
  <D.27063>:
  opts = monoeg_g_strsplit (env, ",", -1);
  ptr = opts;
  goto <D.25445>;
  <D.25444>:
  stderr.100 = stderr;
  fprintf (stderr.100, "Invalid format for the MONO_GCMAP_DEBUG env variable: \'%s\'\n", env);
  exit (1);
  ptr = ptr + 4;
  <D.25445>:
  if (ptr != 0B) goto <D.27065>; else goto <D.25446>;
  <D.27065>:
  D.27066 = *ptr;
  if (D.27066 != 0B) goto <D.25444>; else goto <D.25446>;
  <D.25446>:
  monoeg_g_strfreev (opts);
}


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

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


mini_gc_init_cfg (struct MonoCompile * cfg)
{
  int D.27070;

  D.27070 = mono_gc_is_moving ();
  if (D.27070 != 0) goto <D.27071>; else goto <D.27072>;
  <D.27071>:
  cfg->disable_ref_noref_stack_slot_share = 1;
  cfg->gen_write_barriers = 1;
  <D.27072>:
  mini_gc_init_gc_map (cfg);
}


mini_gc_init_gc_map (struct MonoCompile * cfg)
{
  int D.27075;
  unsigned char D.27078;
  unsigned char D.27079;
  int enable_gc_maps_for_aot.101;
  int D.27086;
  int precise_count.102;
  int precise_count.103;
  const gchar * D.27091;
  const gchar * D.27094;
  int D.27095;
  struct MonoMethod * D.27098;
  char * D.27099;
  const gchar * D.27100;
  int D.27101;
  struct MonoMemPool * D.27104;
  void * D.27105;

  if (0 != 0) goto <D.27073>; else goto <D.27074>;
  <D.27073>:
  return;
  <D.27074>:
  D.27075 = mono_gc_is_moving ();
  if (D.27075 == 0) goto <D.27076>; else goto <D.27077>;
  <D.27076>:
  return;
  <D.27077>:
  D.27078 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.27079 = D.27078 & 64;
  if (D.27079 != 0) goto <D.27080>; else goto <D.27081>;
  <D.27080>:
  enable_gc_maps_for_aot.101 = enable_gc_maps_for_aot;
  if (enable_gc_maps_for_aot.101 == 0) goto <D.27083>; else goto <D.27084>;
  <D.27083>:
  return;
  <D.27084>:
  goto <D.27085>;
  <D.27081>:
  D.27086 = mono_gc_precise_stack_mark_enabled ();
  if (D.27086 == 0) goto <D.27087>; else goto <D.27088>;
  <D.27087>:
  return;
  <D.27088>:
  <D.27085>:
  {
    static int precise_count;

    precise_count.102 = precise_count;
    precise_count.103 = precise_count.102 + 1;
    precise_count = precise_count.103;
    D.27091 = monoeg_g_getenv ("MONO_GCMAP_COUNT");
    if (D.27091 != 0B) goto <D.27092>; else goto <D.27093>;
    <D.27092>:
    D.27094 = monoeg_g_getenv ("MONO_GCMAP_COUNT");
    D.27095 = atoi (D.27094);
    precise_count.102 = precise_count;
    if (D.27095 == precise_count.102) goto <D.27096>; else goto <D.27097>;
    <D.27096>:
    D.27098 = cfg->method;
    D.27099 = mono_method_full_name (D.27098, 1);
    printf ("LAST: %s\n", D.27099);
    <D.27097>:
    D.27100 = monoeg_g_getenv ("MONO_GCMAP_COUNT");
    D.27101 = atoi (D.27100);
    precise_count.102 = precise_count;
    if (D.27101 < precise_count.102) goto <D.27102>; else goto <D.27103>;
    <D.27102>:
    return;
    <D.27103>:
    <D.27093>:
  }
  cfg->compute_gc_maps = 1;
  D.27104 = cfg->mempool;
  D.27105 = mono_mempool_alloc0 (D.27104, 64);
  cfg->gc_info = D.27105;
}