sgen_marksweep_init (struct SgenMajorCollector * collector)
{
  sgen_marksweep_init_internal (collector, 0);
}


sgen_marksweep_init_internal (struct SgenMajorCollector * collector, gboolean is_concurrent)
{
  int num_block_obj_sizes.0;
  int num_block_obj_sizes.1;
  long unsigned int D.20236;
  long unsigned int D.20237;
  void * block_obj_sizes.2;
  int * block_obj_sizes.3;
  void * evacuate_block_obj_sizes.4;
  gboolean * evacuate_block_obj_sizes.5;
  long unsigned int D.20242;
  long unsigned int D.20243;
  gboolean * D.20244;
  int D.20245;
  int D.20246;
  int iftmp.6;
  int D.20248;
  int D.20249;
  int D.20253;
  _Bool D.20254;
  long int D.20255;
  long int D.20256;
  int i;

  sgen_register_fixed_internal_mem_type (16, 320);
  num_block_obj_sizes.0 = ms_calculate_block_obj_sizes (1.4142135623730951454746218587388284504413604736328125e+0, 0B);
  num_block_obj_sizes = num_block_obj_sizes.0;
  num_block_obj_sizes.1 = num_block_obj_sizes;
  D.20236 = (long unsigned int) num_block_obj_sizes.1;
  D.20237 = D.20236 * 4;
  block_obj_sizes.2 = sgen_alloc_internal_dynamic (D.20237, 15, 1);
  block_obj_sizes = block_obj_sizes.2;
  block_obj_sizes.3 = block_obj_sizes;
  ms_calculate_block_obj_sizes (1.4142135623730951454746218587388284504413604736328125e+0, block_obj_sizes.3);
  num_block_obj_sizes.1 = num_block_obj_sizes;
  D.20236 = (long unsigned int) num_block_obj_sizes.1;
  D.20237 = D.20236 * 4;
  evacuate_block_obj_sizes.4 = sgen_alloc_internal_dynamic (D.20237, 15, 1);
  evacuate_block_obj_sizes = evacuate_block_obj_sizes.4;
  i = 0;
  goto <D.20219>;
  <D.20218>:
  evacuate_block_obj_sizes.5 = evacuate_block_obj_sizes;
  D.20242 = (long unsigned int) i;
  D.20243 = D.20242 * 4;
  D.20244 = evacuate_block_obj_sizes.5 + D.20243;
  *D.20244 = 0;
  i = i + 1;
  <D.20219>:
  num_block_obj_sizes.1 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.1) goto <D.20218>; else goto <D.20220>;
  <D.20220>:
  alloc_free_block_lists (&free_block_lists);
  i = 0;
  goto <D.20222>;
  <D.20221>:
  D.20245 = i * 8;
  D.20246 = ms_find_block_obj_size_index (D.20245);
  fast_block_obj_size_indexes[i] = D.20246;
  i = i + 1;
  <D.20222>:
  if (i <= 31) goto <D.20221>; else goto <D.20223>;
  <D.20223>:
  i = 0;
  goto <D.20225>;
  <D.20224>:
  D.20248 = i + 7;
  D.20249 = D.20248 >> 3;
  if (D.20249 <= 31) goto <D.20250>; else goto <D.20251>;
  <D.20250>:
  D.20248 = i + 7;
  D.20249 = D.20248 >> 3;
  iftmp.6 = fast_block_obj_size_indexes[D.20249];
  goto <D.20252>;
  <D.20251>:
  iftmp.6 = ms_find_block_obj_size_index (i);
  <D.20252>:
  D.20253 = ms_find_block_obj_size_index (i);
  D.20254 = iftmp.6 != D.20253;
  D.20255 = (long int) D.20254;
  D.20256 = __builtin_expect (D.20255, 0);
  if (D.20256 != 0) goto <D.20257>; else goto <D.20258>;
  <D.20257>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 2510, "MS_BLOCK_OBJ_SIZE_INDEX (i) == ms_find_block_obj_size_index (i)");
  <D.20258>:
  i = i + 1;
  <D.20225>:
  if (i <= 255) goto <D.20224>; else goto <D.20226>;
  <D.20226>:
  mono_counters_register ("# major blocks allocated", 515, &stat_major_blocks_alloced);
  mono_counters_register ("# major blocks freed", 515, &stat_major_blocks_freed);
  mono_counters_register ("# major blocks lazy swept", 515, &stat_major_blocks_lazy_swept);
  mono_counters_register ("# major objects evacuated", 515, &stat_major_objects_evacuated);
  collector->section_size = 16384;
  collector->is_parallel = 0;
  concurrent_mark = is_concurrent;
  if (is_concurrent != 0) goto <D.20259>; else goto <D.20260>;
  <D.20259>:
  collector->is_concurrent = 1;
  collector->want_synchronous_collection = &want_evacuation;
  collector->get_and_reset_num_major_objects_marked = major_get_and_reset_num_major_objects_marked;
  goto <D.20261>;
  <D.20260>:
  collector->is_concurrent = 0;
  collector->want_synchronous_collection = 0B;
  <D.20261>:
  collector->supports_cardtable = 1;
  collector->have_swept = &have_swept;
  collector->alloc_heap = major_alloc_heap;
  collector->is_object_live = major_is_object_live;
  collector->alloc_small_pinned_obj = major_alloc_small_pinned_obj;
  collector->alloc_degraded = major_alloc_degraded;
  collector->alloc_object = major_alloc_object;
  collector->free_pinned_object = free_pinned_object;
  collector->iterate_objects = major_iterate_objects;
  collector->free_non_pinned_object = major_free_non_pinned_object;
  collector->find_pin_queue_start_ends = major_find_pin_queue_start_ends;
  collector->pin_objects = major_pin_objects;
  collector->pin_major_object = pin_major_object;
  collector->scan_card_table = major_scan_card_table;
  collector->iterate_live_block_ranges = major_iterate_live_block_ranges;
  if (is_concurrent != 0) goto <D.20262>; else goto <D.20263>;
  <D.20262>:
  collector->update_cardtable_mod_union = update_cardtable_mod_union;
  collector->get_cardtable_mod_union_for_object = major_get_cardtable_mod_union_for_object;
  <D.20263>:
  collector->init_to_space = major_init_to_space;
  collector->sweep = major_sweep;
  collector->check_scan_starts = major_check_scan_starts;
  collector->dump_heap = major_dump_heap;
  collector->get_used_size = major_get_used_size;
  collector->start_nursery_collection = major_start_nursery_collection;
  collector->finish_nursery_collection = major_finish_nursery_collection;
  collector->start_major_collection = major_start_major_collection;
  collector->finish_major_collection = major_finish_major_collection;
  collector->have_computed_minor_collection_allowance = major_have_computer_minor_collection_allowance;
  collector->ptr_is_in_non_pinned_space = major_ptr_is_in_non_pinned_space;
  collector->obj_is_from_pinned_alloc = obj_is_from_pinned_alloc;
  collector->report_pinned_memory_usage = major_report_pinned_memory_usage;
  collector->get_num_major_sections = get_num_major_sections;
  collector->handle_gc_param = major_handle_gc_param;
  collector->print_gc_param_usage = major_print_gc_param_usage;
  collector->post_param_init = post_param_init;
  collector->is_valid_object = major_is_valid_object;
  collector->describe_pointer = major_describe_pointer;
  collector->major_ops.copy_or_mark_object = major_copy_or_mark_object_canonical;
  collector->major_ops.scan_object = major_scan_object;
  if (is_concurrent != 0) goto <D.20264>; else goto <D.20265>;
  <D.20264>:
  collector->major_concurrent_ops.copy_or_mark_object = major_copy_or_mark_object_concurrent_canonical;
  collector->major_concurrent_ops.scan_object = major_scan_object_concurrent;
  collector->major_concurrent_ops.scan_vtype = major_scan_vtype_concurrent;
  <D.20265>:
  if (0 != 0) goto <D.20266>; else goto <D.20267>;
  <D.20266>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 2612, "(MS_BLOCK_SIZE % (8 * CARD_SIZE_IN_BYTES)) == 0");
  <D.20267>:
}


major_scan_vtype_concurrent (char * start, mword desc, struct SgenGrayQueue * queue)
{
  long unsigned int D.20268;
  long unsigned int D.20269;
  long unsigned int D.20272;
  long unsigned int D.20273;
  long unsigned int D.20274;
  long unsigned int D.20275;
  long unsigned int D.20276;
  long unsigned int D.20277;
  int D.20281;
  void * D.20287;
  struct FILE * gc_debug_file.7;
  int iftmp.8;
  int D.20292;
  int D.20294;
  _Bool D.20296;
  long int D.20297;
  long int D.20298;
  int iftmp.9;
  int D.20304;
  int D.20306;
  _Bool D.20308;
  long int D.20309;
  long int D.20310;
  int D.20316;
  int iftmp.10;
  int D.20325;
  int D.20327;
  _Bool D.20329;
  long int D.20330;
  long int D.20331;
  int iftmp.11;
  int D.20337;
  int D.20339;
  _Bool D.20341;
  long int D.20342;
  long int D.20343;
  long unsigned int D.20346;
  long unsigned int D.20347;
  int D.20348;
  int D.20352;
  void * D.20358;
  int iftmp.12;
  int D.20362;
  int D.20364;
  _Bool D.20366;
  long int D.20367;
  long int D.20368;
  int iftmp.13;
  int D.20374;
  int D.20376;
  _Bool D.20378;
  long int D.20379;
  long int D.20380;
  long unsigned int D.20383;
  long unsigned int D.20384;
  int D.20385;
  int D.20389;
  int iftmp.14;
  int D.20398;
  int D.20400;
  _Bool D.20402;
  long int D.20403;
  long int D.20404;
  int iftmp.15;
  int D.20410;
  int D.20412;
  _Bool D.20414;
  long int D.20415;
  long int D.20416;
  long unsigned int D.20419;
  long unsigned int D.20422;
  int D.20423;
  int D.20424;
  unsigned int D.20427;
  unsigned int el_size.16;
  unsigned int D.20429;
  sizetype D.20430;
  int D.20434;
  void * D.20440;
  int iftmp.17;
  int D.20444;
  int D.20446;
  _Bool D.20448;
  long int D.20449;
  long int D.20450;
  int iftmp.18;
  int D.20456;
  int D.20458;
  _Bool D.20460;
  long int D.20461;
  long int D.20462;
  int D.20468;
  int D.20469;
  long unsigned int D.20470;
  long unsigned int D.20471;
  long unsigned int D.20472;
  long unsigned int D.20473;
  void * * D.20474;
  int D.20478;
  void * D.20484;
  int iftmp.19;
  int D.20488;
  void * D.20490;
  int D.20491;
  _Bool D.20493;
  long int D.20494;
  long int D.20495;
  void * D.20498;
  int iftmp.20;
  int D.20502;
  int D.20504;
  _Bool D.20506;
  long int D.20507;
  long int D.20508;
  sizetype D.20511;
  long unsigned int D.20515;
  int D.20521;
  void * D.20527;
  int iftmp.21;
  int D.20531;
  int D.20533;
  _Bool D.20535;
  long int D.20536;
  long int D.20537;
  int iftmp.22;
  int D.20543;
  int D.20545;
  _Bool D.20547;
  long int D.20548;
  long int D.20549;
  long unsigned int D.20552;
  int D.20558;
  void * D.20564;
  int iftmp.23;
  int D.20568;
  int D.20570;
  _Bool D.20572;
  long int D.20573;
  long int D.20574;
  int iftmp.24;
  int D.20580;
  int D.20582;
  _Bool D.20584;
  long int D.20585;
  long int D.20586;
  long unsigned int D.20589;
  unsigned int D.20590;
  unsigned int D.20591;
  struct MonoVTable * D.20594;
  struct MonoClass * D.20595;
  const char * D.20596;
  const char * D.20597;
  gsize * bitmap_data.25;
  long unsigned int D.20599;
  int D.20605;
  void * D.20611;
  int iftmp.26;
  int D.20615;
  int D.20617;
  _Bool D.20619;
  long int D.20620;
  long int D.20621;
  int iftmp.27;
  int D.20627;
  int D.20629;
  _Bool D.20631;
  long int D.20632;
  long int D.20633;
  int bwords.28;

  start = start + 18446744073709551600;
  D.20268 = desc & 7;
  switch (D.20268) <default: <D.19908>, case 1: <D.19825>, case 2: <D.19836>, case 3: <D.19892>, case 4: <D.19848>, case 5: <D.19884>, case 7: <D.19907>>
  <D.19825>:
  D.20269 = desc & 4294901760;
  if (D.20269 != 0) goto <D.20270>; else goto <D.20271>;
  <D.20270>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.20272 = desc >> 16;
    D.20273 = D.20272 & 255;
    D.20274 = D.20273 * 8;
    _objptr = _objptr + D.20274;
    D.20275 = desc >> 24;
    D.20276 = D.20275 & 255;
    D.20277 = D.20276 * 8;
    _objptr_end = _objptr + D.20277;
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.20280>; else goto <D.20278>;
      <D.20280>:
      D.20281 = sgen_ptr_in_nursery (__old);
      if (D.20281 == 0) goto <D.20282>; else goto <D.20278>;
      <D.20282>:
      __builtin_prefetch (__old);
      major_copy_or_mark_object_concurrent (_objptr, __old, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.20283>; else goto <D.20284>;
      <D.20283>:
      if (__old != __copy) goto <D.20285>; else goto <D.20286>;
      <D.20285>:
      D.20287 = *_objptr;
      gc_debug_file.7 = gc_debug_file;
      fprintf (gc_debug_file.7, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20287, __old);
      gc_debug_file.7 = gc_debug_file;
      fflush (gc_debug_file.7);
      <D.20286>:
      <D.20284>:
      D.20292 = sgen_ptr_in_nursery (__copy);
      if (D.20292 != 0) goto <D.20293>; else goto <D.20290>;
      <D.20293>:
      D.20294 = sgen_ptr_in_nursery (_objptr);
      if (D.20294 == 0) goto <D.20295>; else goto <D.20290>;
      <D.20295>:
      iftmp.8 = 1;
      goto <D.20291>;
      <D.20290>:
      iftmp.8 = 0;
      <D.20291>:
      D.20296 = iftmp.8 != 0;
      D.20297 = (long int) D.20296;
      D.20298 = __builtin_expect (D.20297, 0);
      if (D.20298 != 0) goto <D.20299>; else goto <D.20300>;
      <D.20299>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.20300>:
      goto <D.20279>;
      <D.20278>:
      D.20304 = sgen_ptr_in_nursery (__old);
      if (D.20304 != 0) goto <D.20305>; else goto <D.20302>;
      <D.20305>:
      D.20306 = sgen_ptr_in_nursery (_objptr);
      if (D.20306 == 0) goto <D.20307>; else goto <D.20302>;
      <D.20307>:
      iftmp.9 = 1;
      goto <D.20303>;
      <D.20302>:
      iftmp.9 = 0;
      <D.20303>:
      D.20308 = iftmp.9 != 0;
      D.20309 = (long int) D.20308;
      D.20310 = __builtin_expect (D.20309, 0);
      if (D.20310 != 0) goto <D.20311>; else goto <D.20312>;
      <D.20311>:
      sgen_add_to_global_remset (_objptr, __old);
      <D.20312>:
      <D.20279>:
    }
    _objptr = _objptr + 8;
    goto <D.19833>;
    <D.19832>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.20315>; else goto <D.20313>;
      <D.20315>:
      D.20316 = sgen_ptr_in_nursery (__old);
      if (D.20316 == 0) goto <D.20317>; else goto <D.20313>;
      <D.20317>:
      __builtin_prefetch (__old);
      major_copy_or_mark_object_concurrent (_objptr, __old, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.20318>; else goto <D.20319>;
      <D.20318>:
      if (__old != __copy) goto <D.20320>; else goto <D.20321>;
      <D.20320>:
      D.20287 = *_objptr;
      gc_debug_file.7 = gc_debug_file;
      fprintf (gc_debug_file.7, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20287, __old);
      gc_debug_file.7 = gc_debug_file;
      fflush (gc_debug_file.7);
      <D.20321>:
      <D.20319>:
      D.20325 = sgen_ptr_in_nursery (__copy);
      if (D.20325 != 0) goto <D.20326>; else goto <D.20323>;
      <D.20326>:
      D.20327 = sgen_ptr_in_nursery (_objptr);
      if (D.20327 == 0) goto <D.20328>; else goto <D.20323>;
      <D.20328>:
      iftmp.10 = 1;
      goto <D.20324>;
      <D.20323>:
      iftmp.10 = 0;
      <D.20324>:
      D.20329 = iftmp.10 != 0;
      D.20330 = (long int) D.20329;
      D.20331 = __builtin_expect (D.20330, 0);
      if (D.20331 != 0) goto <D.20332>; else goto <D.20333>;
      <D.20332>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.20333>:
      goto <D.20314>;
      <D.20313>:
      D.20337 = sgen_ptr_in_nursery (__old);
      if (D.20337 != 0) goto <D.20338>; else goto <D.20335>;
      <D.20338>:
      D.20339 = sgen_ptr_in_nursery (_objptr);
      if (D.20339 == 0) goto <D.20340>; else goto <D.20335>;
      <D.20340>:
      iftmp.11 = 1;
      goto <D.20336>;
      <D.20335>:
      iftmp.11 = 0;
      <D.20336>:
      D.20341 = iftmp.11 != 0;
      D.20342 = (long int) D.20341;
      D.20343 = __builtin_expect (D.20342, 0);
      if (D.20343 != 0) goto <D.20344>; else goto <D.20345>;
      <D.20344>:
      sgen_add_to_global_remset (_objptr, __old);
      <D.20345>:
      <D.20314>:
    }
    _objptr = _objptr + 8;
    <D.19833>:
    if (_objptr < _objptr_end) goto <D.19832>; else goto <D.19834>;
    <D.19834>:
  }
  <D.20271>:
  goto <D.19835>;
  <D.19836>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 16;
    _objptr = _objptr + 16;
    {
      int _index;

      _index = __builtin_ctzl (_bmap);
      D.20346 = (long unsigned int) _index;
      D.20347 = D.20346 * 8;
      _objptr = _objptr + D.20347;
      D.20348 = _index + 1;
      _bmap = _bmap >> D.20348;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.20351>; else goto <D.20349>;
        <D.20351>:
        D.20352 = sgen_ptr_in_nursery (__old);
        if (D.20352 == 0) goto <D.20353>; else goto <D.20349>;
        <D.20353>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.20354>; else goto <D.20355>;
        <D.20354>:
        if (__old != __copy) goto <D.20356>; else goto <D.20357>;
        <D.20356>:
        D.20358 = *_objptr;
        gc_debug_file.7 = gc_debug_file;
        fprintf (gc_debug_file.7, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20358, __old);
        gc_debug_file.7 = gc_debug_file;
        fflush (gc_debug_file.7);
        <D.20357>:
        <D.20355>:
        D.20362 = sgen_ptr_in_nursery (__copy);
        if (D.20362 != 0) goto <D.20363>; else goto <D.20360>;
        <D.20363>:
        D.20364 = sgen_ptr_in_nursery (_objptr);
        if (D.20364 == 0) goto <D.20365>; else goto <D.20360>;
        <D.20365>:
        iftmp.12 = 1;
        goto <D.20361>;
        <D.20360>:
        iftmp.12 = 0;
        <D.20361>:
        D.20366 = iftmp.12 != 0;
        D.20367 = (long int) D.20366;
        D.20368 = __builtin_expect (D.20367, 0);
        if (D.20368 != 0) goto <D.20369>; else goto <D.20370>;
        <D.20369>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20370>:
        goto <D.20350>;
        <D.20349>:
        D.20374 = sgen_ptr_in_nursery (__old);
        if (D.20374 != 0) goto <D.20375>; else goto <D.20372>;
        <D.20375>:
        D.20376 = sgen_ptr_in_nursery (_objptr);
        if (D.20376 == 0) goto <D.20377>; else goto <D.20372>;
        <D.20377>:
        iftmp.13 = 1;
        goto <D.20373>;
        <D.20372>:
        iftmp.13 = 0;
        <D.20373>:
        D.20378 = iftmp.13 != 0;
        D.20379 = (long int) D.20378;
        D.20380 = __builtin_expect (D.20379, 0);
        if (D.20380 != 0) goto <D.20381>; else goto <D.20382>;
        <D.20381>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.20382>:
        <D.20350>:
      }
      _objptr = _objptr + 8;
    }
    goto <D.19846>;
    <D.19845>:
    {
      int _index;

      _index = __builtin_ctzl (_bmap);
      D.20383 = (long unsigned int) _index;
      D.20384 = D.20383 * 8;
      _objptr = _objptr + D.20384;
      D.20385 = _index + 1;
      _bmap = _bmap >> D.20385;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.20388>; else goto <D.20386>;
        <D.20388>:
        D.20389 = sgen_ptr_in_nursery (__old);
        if (D.20389 == 0) goto <D.20390>; else goto <D.20386>;
        <D.20390>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.20391>; else goto <D.20392>;
        <D.20391>:
        if (__old != __copy) goto <D.20393>; else goto <D.20394>;
        <D.20393>:
        D.20358 = *_objptr;
        gc_debug_file.7 = gc_debug_file;
        fprintf (gc_debug_file.7, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20358, __old);
        gc_debug_file.7 = gc_debug_file;
        fflush (gc_debug_file.7);
        <D.20394>:
        <D.20392>:
        D.20398 = sgen_ptr_in_nursery (__copy);
        if (D.20398 != 0) goto <D.20399>; else goto <D.20396>;
        <D.20399>:
        D.20400 = sgen_ptr_in_nursery (_objptr);
        if (D.20400 == 0) goto <D.20401>; else goto <D.20396>;
        <D.20401>:
        iftmp.14 = 1;
        goto <D.20397>;
        <D.20396>:
        iftmp.14 = 0;
        <D.20397>:
        D.20402 = iftmp.14 != 0;
        D.20403 = (long int) D.20402;
        D.20404 = __builtin_expect (D.20403, 0);
        if (D.20404 != 0) goto <D.20405>; else goto <D.20406>;
        <D.20405>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20406>:
        goto <D.20387>;
        <D.20386>:
        D.20410 = sgen_ptr_in_nursery (__old);
        if (D.20410 != 0) goto <D.20411>; else goto <D.20408>;
        <D.20411>:
        D.20412 = sgen_ptr_in_nursery (_objptr);
        if (D.20412 == 0) goto <D.20413>; else goto <D.20408>;
        <D.20413>:
        iftmp.15 = 1;
        goto <D.20409>;
        <D.20408>:
        iftmp.15 = 0;
        <D.20409>:
        D.20414 = iftmp.15 != 0;
        D.20415 = (long int) D.20414;
        D.20416 = __builtin_expect (D.20415, 0);
        if (D.20416 != 0) goto <D.20417>; else goto <D.20418>;
        <D.20417>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.20418>:
        <D.20387>:
      }
      _objptr = _objptr + 8;
    }
    <D.19846>:
    if (_bmap != 0) goto <D.19845>; else goto <D.19847>;
    <D.19847>:
  }
  goto <D.19835>;
  <D.19848>:
  D.20419 = desc & 4294950912;
  if (D.20419 != 0) goto <D.20420>; else goto <D.20421>;
  <D.20420>:
  {
    int el_size;
    int etype;

    D.20422 = desc >> 3;
    D.20423 = (int) D.20422;
    el_size = D.20423 & 1023;
    D.20424 = (int) desc;
    etype = D.20424 & 49152;
    if (etype == 16384) goto <D.20425>; else goto <D.20426>;
    <D.20425>:
    {
      void * * p;
      void * * end_refs;

      p = start + 32;
      D.20427 = MEM[(struct MonoArray *)start].max_length;
      el_size.16 = (unsigned int) el_size;
      D.20429 = D.20427 * el_size.16;
      D.20430 = (sizetype) D.20429;
      end_refs = p + D.20430;
      goto <D.19856>;
      <D.19855>:
      {
        void * __old;
        void * __copy;

        __old = *p;
        if (__old != 0B) goto <D.20433>; else goto <D.20431>;
        <D.20433>:
        D.20434 = sgen_ptr_in_nursery (__old);
        if (D.20434 == 0) goto <D.20435>; else goto <D.20431>;
        <D.20435>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (p, __old, queue);
        __copy = *p;
        if (0 != 0) goto <D.20436>; else goto <D.20437>;
        <D.20436>:
        if (__old != __copy) goto <D.20438>; else goto <D.20439>;
        <D.20438>:
        D.20440 = *p;
        gc_debug_file.7 = gc_debug_file;
        fprintf (gc_debug_file.7, "Overwrote field at %p with %p (was: %p)\n", p, D.20440, __old);
        gc_debug_file.7 = gc_debug_file;
        fflush (gc_debug_file.7);
        <D.20439>:
        <D.20437>:
        D.20444 = sgen_ptr_in_nursery (__copy);
        if (D.20444 != 0) goto <D.20445>; else goto <D.20442>;
        <D.20445>:
        D.20446 = sgen_ptr_in_nursery (p);
        if (D.20446 == 0) goto <D.20447>; else goto <D.20442>;
        <D.20447>:
        iftmp.17 = 1;
        goto <D.20443>;
        <D.20442>:
        iftmp.17 = 0;
        <D.20443>:
        D.20448 = iftmp.17 != 0;
        D.20449 = (long int) D.20448;
        D.20450 = __builtin_expect (D.20449, 0);
        if (D.20450 != 0) goto <D.20451>; else goto <D.20452>;
        <D.20451>:
        sgen_add_to_global_remset (p, __copy);
        <D.20452>:
        goto <D.20432>;
        <D.20431>:
        D.20456 = sgen_ptr_in_nursery (__old);
        if (D.20456 != 0) goto <D.20457>; else goto <D.20454>;
        <D.20457>:
        D.20458 = sgen_ptr_in_nursery (p);
        if (D.20458 == 0) goto <D.20459>; else goto <D.20454>;
        <D.20459>:
        iftmp.18 = 1;
        goto <D.20455>;
        <D.20454>:
        iftmp.18 = 0;
        <D.20455>:
        D.20460 = iftmp.18 != 0;
        D.20461 = (long int) D.20460;
        D.20462 = __builtin_expect (D.20461, 0);
        if (D.20462 != 0) goto <D.20463>; else goto <D.20464>;
        <D.20463>:
        sgen_add_to_global_remset (p, __old);
        <D.20464>:
        <D.20432>:
      }
      p = p + 8;
      <D.19856>:
      if (p < end_refs) goto <D.19855>; else goto <D.19857>;
      <D.19857>:
    }
    goto <D.20465>;
    <D.20426>:
    if (etype == 32768) goto <D.20466>; else goto <D.20467>;
    <D.20466>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.20272 = desc >> 16;
      D.20468 = (int) D.20272;
      offset = D.20468 & 255;
      D.20275 = desc >> 24;
      D.20469 = (int) D.20275;
      num_refs = D.20469 & 255;
      e_start = start + 32;
      D.20427 = MEM[(struct MonoArray *)start].max_length;
      el_size.16 = (unsigned int) el_size;
      D.20429 = D.20427 * el_size.16;
      D.20430 = (sizetype) D.20429;
      e_end = e_start + D.20430;
      goto <D.19870>;
      <D.19869>:
      {
        void * * p;
        int i;

        p = e_start;
        D.20470 = (long unsigned int) offset;
        D.20471 = D.20470 * 8;
        p = p + D.20471;
        i = 0;
        goto <D.19867>;
        <D.19866>:
        {
          void * __old;
          void * __copy;

          D.20472 = (long unsigned int) i;
          D.20473 = D.20472 * 8;
          D.20474 = p + D.20473;
          __old = *D.20474;
          if (__old != 0B) goto <D.20477>; else goto <D.20475>;
          <D.20477>:
          D.20478 = sgen_ptr_in_nursery (__old);
          if (D.20478 == 0) goto <D.20479>; else goto <D.20475>;
          <D.20479>:
          __builtin_prefetch (__old);
          D.20472 = (long unsigned int) i;
          D.20473 = D.20472 * 8;
          D.20474 = p + D.20473;
          major_copy_or_mark_object_concurrent (D.20474, __old, queue);
          D.20472 = (long unsigned int) i;
          D.20473 = D.20472 * 8;
          D.20474 = p + D.20473;
          __copy = *D.20474;
          if (0 != 0) goto <D.20480>; else goto <D.20481>;
          <D.20480>:
          if (__old != __copy) goto <D.20482>; else goto <D.20483>;
          <D.20482>:
          D.20472 = (long unsigned int) i;
          D.20473 = D.20472 * 8;
          D.20474 = p + D.20473;
          D.20484 = *D.20474;
          D.20472 = (long unsigned int) i;
          D.20473 = D.20472 * 8;
          D.20474 = p + D.20473;
          gc_debug_file.7 = gc_debug_file;
          fprintf (gc_debug_file.7, "Overwrote field at %p with %p (was: %p)\n", D.20474, D.20484, __old);
          gc_debug_file.7 = gc_debug_file;
          fflush (gc_debug_file.7);
          <D.20483>:
          <D.20481>:
          D.20488 = sgen_ptr_in_nursery (__copy);
          if (D.20488 != 0) goto <D.20489>; else goto <D.20486>;
          <D.20489>:
          D.20472 = (long unsigned int) i;
          D.20473 = D.20472 * 8;
          D.20490 = p + D.20473;
          D.20491 = sgen_ptr_in_nursery (D.20490);
          if (D.20491 == 0) goto <D.20492>; else goto <D.20486>;
          <D.20492>:
          iftmp.19 = 1;
          goto <D.20487>;
          <D.20486>:
          iftmp.19 = 0;
          <D.20487>:
          D.20493 = iftmp.19 != 0;
          D.20494 = (long int) D.20493;
          D.20495 = __builtin_expect (D.20494, 0);
          if (D.20495 != 0) goto <D.20496>; else goto <D.20497>;
          <D.20496>:
          D.20472 = (long unsigned int) i;
          D.20473 = D.20472 * 8;
          D.20498 = p + D.20473;
          sgen_add_to_global_remset (D.20498, __copy);
          <D.20497>:
          goto <D.20476>;
          <D.20475>:
          D.20502 = sgen_ptr_in_nursery (__old);
          if (D.20502 != 0) goto <D.20503>; else goto <D.20500>;
          <D.20503>:
          D.20472 = (long unsigned int) i;
          D.20473 = D.20472 * 8;
          D.20490 = p + D.20473;
          D.20504 = sgen_ptr_in_nursery (D.20490);
          if (D.20504 == 0) goto <D.20505>; else goto <D.20500>;
          <D.20505>:
          iftmp.20 = 1;
          goto <D.20501>;
          <D.20500>:
          iftmp.20 = 0;
          <D.20501>:
          D.20506 = iftmp.20 != 0;
          D.20507 = (long int) D.20506;
          D.20508 = __builtin_expect (D.20507, 0);
          if (D.20508 != 0) goto <D.20509>; else goto <D.20510>;
          <D.20509>:
          D.20472 = (long unsigned int) i;
          D.20473 = D.20472 * 8;
          D.20498 = p + D.20473;
          sgen_add_to_global_remset (D.20498, __old);
          <D.20510>:
          <D.20476>:
        }
        i = i + 1;
        <D.19867>:
        if (i < num_refs) goto <D.19866>; else goto <D.19868>;
        <D.19868>:
        D.20511 = (sizetype) el_size;
        e_start = e_start + D.20511;
      }
      <D.19870>:
      if (e_start < e_end) goto <D.19869>; else goto <D.19871>;
      <D.19871>:
    }
    goto <D.20512>;
    <D.20467>:
    if (etype == 49152) goto <D.20513>; else goto <D.20514>;
    <D.20513>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 32;
      D.20427 = MEM[(struct MonoArray *)start].max_length;
      el_size.16 = (unsigned int) el_size;
      D.20429 = D.20427 * el_size.16;
      D.20430 = (sizetype) D.20429;
      e_end = e_start + D.20430;
      goto <D.19882>;
      <D.19881>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.19879>;
        <D.19878>:
        D.20515 = _bmap & 1;
        if (D.20515 != 0) goto <D.20516>; else goto <D.20517>;
        <D.20516>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.20520>; else goto <D.20518>;
          <D.20520>:
          D.20521 = sgen_ptr_in_nursery (__old);
          if (D.20521 == 0) goto <D.20522>; else goto <D.20518>;
          <D.20522>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object_concurrent (p, __old, queue);
          __copy = *p;
          if (0 != 0) goto <D.20523>; else goto <D.20524>;
          <D.20523>:
          if (__old != __copy) goto <D.20525>; else goto <D.20526>;
          <D.20525>:
          D.20527 = *p;
          gc_debug_file.7 = gc_debug_file;
          fprintf (gc_debug_file.7, "Overwrote field at %p with %p (was: %p)\n", p, D.20527, __old);
          gc_debug_file.7 = gc_debug_file;
          fflush (gc_debug_file.7);
          <D.20526>:
          <D.20524>:
          D.20531 = sgen_ptr_in_nursery (__copy);
          if (D.20531 != 0) goto <D.20532>; else goto <D.20529>;
          <D.20532>:
          D.20533 = sgen_ptr_in_nursery (p);
          if (D.20533 == 0) goto <D.20534>; else goto <D.20529>;
          <D.20534>:
          iftmp.21 = 1;
          goto <D.20530>;
          <D.20529>:
          iftmp.21 = 0;
          <D.20530>:
          D.20535 = iftmp.21 != 0;
          D.20536 = (long int) D.20535;
          D.20537 = __builtin_expect (D.20536, 0);
          if (D.20537 != 0) goto <D.20538>; else goto <D.20539>;
          <D.20538>:
          sgen_add_to_global_remset (p, __copy);
          <D.20539>:
          goto <D.20519>;
          <D.20518>:
          D.20543 = sgen_ptr_in_nursery (__old);
          if (D.20543 != 0) goto <D.20544>; else goto <D.20541>;
          <D.20544>:
          D.20545 = sgen_ptr_in_nursery (p);
          if (D.20545 == 0) goto <D.20546>; else goto <D.20541>;
          <D.20546>:
          iftmp.22 = 1;
          goto <D.20542>;
          <D.20541>:
          iftmp.22 = 0;
          <D.20542>:
          D.20547 = iftmp.22 != 0;
          D.20548 = (long int) D.20547;
          D.20549 = __builtin_expect (D.20548, 0);
          if (D.20549 != 0) goto <D.20550>; else goto <D.20551>;
          <D.20550>:
          sgen_add_to_global_remset (p, __old);
          <D.20551>:
          <D.20519>:
        }
        <D.20517>:
        _bmap = _bmap >> 1;
        p = p + 8;
        <D.19879>:
        if (_bmap != 0) goto <D.19878>; else goto <D.19880>;
        <D.19880>:
        D.20511 = (sizetype) el_size;
        e_start = e_start + D.20511;
      }
      <D.19882>:
      if (e_start < e_end) goto <D.19881>; else goto <D.19883>;
      <D.19883>:
    }
    <D.20514>:
    <D.20512>:
    <D.20465>:
  }
  <D.20421>:
  goto <D.19835>;
  <D.19884>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 3;
    _objptr = _objptr + 16;
    goto <D.19890>;
    <D.19889>:
    D.20552 = _bmap & 1;
    if (D.20552 != 0) goto <D.20553>; else goto <D.20554>;
    <D.20553>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.20557>; else goto <D.20555>;
      <D.20557>:
      D.20558 = sgen_ptr_in_nursery (__old);
      if (D.20558 == 0) goto <D.20559>; else goto <D.20555>;
      <D.20559>:
      __builtin_prefetch (__old);
      major_copy_or_mark_object_concurrent (_objptr, __old, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.20560>; else goto <D.20561>;
      <D.20560>:
      if (__old != __copy) goto <D.20562>; else goto <D.20563>;
      <D.20562>:
      D.20564 = *_objptr;
      gc_debug_file.7 = gc_debug_file;
      fprintf (gc_debug_file.7, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20564, __old);
      gc_debug_file.7 = gc_debug_file;
      fflush (gc_debug_file.7);
      <D.20563>:
      <D.20561>:
      D.20568 = sgen_ptr_in_nursery (__copy);
      if (D.20568 != 0) goto <D.20569>; else goto <D.20566>;
      <D.20569>:
      D.20570 = sgen_ptr_in_nursery (_objptr);
      if (D.20570 == 0) goto <D.20571>; else goto <D.20566>;
      <D.20571>:
      iftmp.23 = 1;
      goto <D.20567>;
      <D.20566>:
      iftmp.23 = 0;
      <D.20567>:
      D.20572 = iftmp.23 != 0;
      D.20573 = (long int) D.20572;
      D.20574 = __builtin_expect (D.20573, 0);
      if (D.20574 != 0) goto <D.20575>; else goto <D.20576>;
      <D.20575>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.20576>:
      goto <D.20556>;
      <D.20555>:
      D.20580 = sgen_ptr_in_nursery (__old);
      if (D.20580 != 0) goto <D.20581>; else goto <D.20578>;
      <D.20581>:
      D.20582 = sgen_ptr_in_nursery (_objptr);
      if (D.20582 == 0) goto <D.20583>; else goto <D.20578>;
      <D.20583>:
      iftmp.24 = 1;
      goto <D.20579>;
      <D.20578>:
      iftmp.24 = 0;
      <D.20579>:
      D.20584 = iftmp.24 != 0;
      D.20585 = (long int) D.20584;
      D.20586 = __builtin_expect (D.20585, 0);
      if (D.20586 != 0) goto <D.20587>; else goto <D.20588>;
      <D.20587>:
      sgen_add_to_global_remset (_objptr, __old);
      <D.20588>:
      <D.20556>:
    }
    <D.20554>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 8;
    <D.19890>:
    if (_bmap != 0) goto <D.19889>; else goto <D.19891>;
    <D.19891>:
  }
  goto <D.19835>;
  <D.19892>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.20589 = *bitmap_data;
    D.20590 = (unsigned int) D.20589;
    D.20591 = D.20590 + 4294967295;
    bwords = (int) D.20591;
    start_run = _objptr;
    bitmap_data = bitmap_data + 8;
    if (0 != 0) goto <D.20592>; else goto <D.20593>;
    <D.20592>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.20594 = myobj->vtable;
      D.20595 = D.20594->klass;
      D.20596 = D.20595->name;
      D.20594 = myobj->vtable;
      D.20595 = D.20594->klass;
      D.20597 = D.20595->name_space;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.20597, D.20596);
    }
    <D.20593>:
    goto <D.19905>;
    <D.19904>:
    {
      gsize _bmap;

      bitmap_data.25 = bitmap_data;
      bitmap_data = bitmap_data.25 + 8;
      _bmap = *bitmap_data.25;
      _objptr = start_run;
      goto <D.19902>;
      <D.19901>:
      D.20599 = _bmap & 1;
      if (D.20599 != 0) goto <D.20600>; else goto <D.20601>;
      <D.20600>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.20604>; else goto <D.20602>;
        <D.20604>:
        D.20605 = sgen_ptr_in_nursery (__old);
        if (D.20605 == 0) goto <D.20606>; else goto <D.20602>;
        <D.20606>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.20607>; else goto <D.20608>;
        <D.20607>:
        if (__old != __copy) goto <D.20609>; else goto <D.20610>;
        <D.20609>:
        D.20611 = *_objptr;
        gc_debug_file.7 = gc_debug_file;
        fprintf (gc_debug_file.7, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20611, __old);
        gc_debug_file.7 = gc_debug_file;
        fflush (gc_debug_file.7);
        <D.20610>:
        <D.20608>:
        D.20615 = sgen_ptr_in_nursery (__copy);
        if (D.20615 != 0) goto <D.20616>; else goto <D.20613>;
        <D.20616>:
        D.20617 = sgen_ptr_in_nursery (_objptr);
        if (D.20617 == 0) goto <D.20618>; else goto <D.20613>;
        <D.20618>:
        iftmp.26 = 1;
        goto <D.20614>;
        <D.20613>:
        iftmp.26 = 0;
        <D.20614>:
        D.20619 = iftmp.26 != 0;
        D.20620 = (long int) D.20619;
        D.20621 = __builtin_expect (D.20620, 0);
        if (D.20621 != 0) goto <D.20622>; else goto <D.20623>;
        <D.20622>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20623>:
        goto <D.20603>;
        <D.20602>:
        D.20627 = sgen_ptr_in_nursery (__old);
        if (D.20627 != 0) goto <D.20628>; else goto <D.20625>;
        <D.20628>:
        D.20629 = sgen_ptr_in_nursery (_objptr);
        if (D.20629 == 0) goto <D.20630>; else goto <D.20625>;
        <D.20630>:
        iftmp.27 = 1;
        goto <D.20626>;
        <D.20625>:
        iftmp.27 = 0;
        <D.20626>:
        D.20631 = iftmp.27 != 0;
        D.20632 = (long int) D.20631;
        D.20633 = __builtin_expect (D.20632, 0);
        if (D.20633 != 0) goto <D.20634>; else goto <D.20635>;
        <D.20634>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.20635>:
        <D.20603>:
      }
      <D.20601>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.19902>:
      if (_bmap != 0) goto <D.19901>; else goto <D.19903>;
      <D.19903>:
      start_run = start_run + 512;
    }
    <D.19905>:
    bwords.28 = bwords;
    bwords = bwords.28 + -1;
    if (bwords.28 > 0) goto <D.19904>; else goto <D.19906>;
    <D.19906>:
  }
  goto <D.19835>;
  <D.19907>:
  goto <D.19835>;
  <D.19908>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.19835>:
}


major_copy_or_mark_object_concurrent (void * * ptr, void * obj, struct SgenGrayQueue * queue)
{
  int iftmp.29;
  long unsigned int D.20641;
  long unsigned int D.20642;
  long unsigned int D.20644;
  _Bool D.20646;
  long int D.20647;
  long int D.20648;
  int D.20651;
  unsigned int D.20654;
  unsigned int D.20655;
  long unsigned int D.20656;
  long unsigned int obj.30;
  long unsigned int D.20660;
  struct MSBlockHeader * D.20661;
  long int obj.31;
  long int obj.32;
  long int D.20664;
  long int D.20665;
  long int D.20666;
  long unsigned int D.20672;
  long int D.20673;
  long unsigned int D.20674;
  long unsigned int D.20675;
  long unsigned int D.20678;
  unsigned char D.20679;
  unsigned char D.20680;
  int iftmp.33;
  struct GrayQueueSection * D.20687;
  int D.20689;
  _Bool D.20690;
  long int D.20691;
  long int D.20692;
  int D.20696;
  int D.20697;
  int D.20699;
  struct MonoVTable * D.20702;
  void * D.20703;
  long unsigned int D.20704;
  int D.20705;
  int iftmp.34;
  _Bool D.20713;
  long int D.20714;
  long int D.20715;
  int D.20719;
  int D.20720;

  D.20641 = MEM[(mword *)obj];
  D.20642 = D.20641 & 1;
  if (D.20642 != 0) goto <D.20643>; else goto <D.20639>;
  <D.20643>:
  D.20641 = MEM[(mword *)obj];
  D.20644 = D.20641 & 18446744073709551612;
  if (D.20644 != 0) goto <D.20645>; else goto <D.20639>;
  <D.20645>:
  iftmp.29 = 1;
  goto <D.20640>;
  <D.20639>:
  iftmp.29 = 0;
  <D.20640>:
  D.20646 = iftmp.29 != 0;
  D.20647 = (long int) D.20646;
  D.20648 = __builtin_expect (D.20647, 0);
  if (D.20648 != 0) goto <D.20649>; else goto <D.20650>;
  <D.20649>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 1280, "!SGEN_OBJECT_IS_FORWARDED (obj)");
  <D.20650>:
  D.20651 = sgen_ptr_in_nursery (obj);
  if (D.20651 == 0) goto <D.20652>; else goto <D.20653>;
  <D.20652>:
  {
    mword objsize;

    D.20654 = sgen_safe_object_get_size (obj);
    D.20655 = D.20654 + 7;
    D.20656 = (long unsigned int) D.20655;
    objsize = D.20656 & 4294967288;
    if (objsize <= 8000) goto <D.20657>; else goto <D.20658>;
    <D.20657>:
    {
      struct MSBlockInfo * block;

      obj.30 = (long unsigned int) obj;
      D.20660 = obj.30 & 18446744073709535232;
      D.20661 = (struct MSBlockHeader *) D.20660;
      block = D.20661->info;
      {
        int __word;
        int __bit;

        {
          int i;

          obj.31 = (long int) obj;
          obj.32 = (long int) obj;
          D.20664 = obj.32 & -16384;
          D.20665 = obj.31 - D.20664;
          D.20666 = D.20665 >> 3;
          i = (int) D.20666;
          if (0 != 0) goto <D.20667>; else goto <D.20668>;
          <D.20667>:
          __word = i >> 5;
          __bit = i & 31;
          goto <D.20669>;
          <D.20668>:
          __word = i >> 6;
          __bit = i & 63;
          <D.20669>:
        }
        if (0 != 0) goto <D.20670>; else goto <D.20671>;
        <D.20670>:
        monoeg_g_log (0B, 4, "object %p not allocated", obj);
        <D.19554>:
        goto <D.19554>;
        <D.20671>:
        D.20672 = block->mark_words[__word];
        D.20673 = 1 << __bit;
        D.20674 = (long unsigned int) D.20673;
        D.20675 = D.20672 & D.20674;
        if (D.20675 == 0) goto <D.20676>; else goto <D.20677>;
        <D.20676>:
        D.20672 = block->mark_words[__word];
        D.20673 = 1 << __bit;
        D.20674 = (long unsigned int) D.20673;
        D.20678 = D.20672 | D.20674;
        block->mark_words[__word] = D.20678;
        D.20679 = BIT_FIELD_REF <*block, 8, 96>;
        D.20680 = D.20679 & 2;
        if (D.20680 != 0) goto <D.20681>; else goto <D.20682>;
        <D.20681>:
        D.20687 = queue->first;
        if (D.20687 == 0B) goto <D.20684>; else goto <D.20688>;
        <D.20688>:
        D.20687 = queue->first;
        D.20689 = D.20687->end;
        if (D.20689 == 125) goto <D.20684>; else goto <D.20685>;
        <D.20684>:
        iftmp.33 = 1;
        goto <D.20686>;
        <D.20685>:
        iftmp.33 = 0;
        <D.20686>:
        D.20690 = iftmp.33 != 0;
        D.20691 = (long int) D.20690;
        D.20692 = __builtin_expect (D.20691, 0);
        if (D.20692 != 0) goto <D.20693>; else goto <D.20694>;
        <D.20693>:
        sgen_gray_object_enqueue (queue, obj);
        goto <D.20695>;
        <D.20694>:
        D.20687 = queue->first;
        D.20687 = queue->first;
        D.20689 = D.20687->end;
        D.20696 = D.20689;
        D.20697 = D.20696 + 1;
        D.20687->end = D.20697;
        D.20687->objects[D.20696] = obj;
        <D.20695>:
        __builtin_prefetch (obj);
        <D.20682>:
        <D.20677>:
      }
    }
    goto <D.20698>;
    <D.20658>:
    D.20699 = sgen_los_object_is_pinned (obj);
    if (D.20699 != 0) goto <D.20700>; else goto <D.20701>;
    <D.20700>:
    return;
    <D.20701>:
    sgen_los_pin_object (obj);
    D.20641 = MEM[(mword *)obj];
    D.20644 = D.20641 & 18446744073709551612;
    D.20702 = (struct MonoVTable *) D.20644;
    D.20703 = D.20702->gc_descr;
    D.20704 = (long unsigned int) D.20703;
    D.20705 = sgen_gc_descr_has_references (D.20704);
    if (D.20705 != 0) goto <D.20706>; else goto <D.20707>;
    <D.20706>:
    D.20687 = queue->first;
    if (D.20687 == 0B) goto <D.20709>; else goto <D.20712>;
    <D.20712>:
    D.20687 = queue->first;
    D.20689 = D.20687->end;
    if (D.20689 == 125) goto <D.20709>; else goto <D.20710>;
    <D.20709>:
    iftmp.34 = 1;
    goto <D.20711>;
    <D.20710>:
    iftmp.34 = 0;
    <D.20711>:
    D.20713 = iftmp.34 != 0;
    D.20714 = (long int) D.20713;
    D.20715 = __builtin_expect (D.20714, 0);
    if (D.20715 != 0) goto <D.20716>; else goto <D.20717>;
    <D.20716>:
    sgen_gray_object_enqueue (queue, obj);
    goto <D.20718>;
    <D.20717>:
    D.20687 = queue->first;
    D.20687 = queue->first;
    D.20689 = D.20687->end;
    D.20719 = D.20689;
    D.20720 = D.20719 + 1;
    D.20687->end = D.20720;
    D.20687->objects[D.20719] = obj;
    <D.20718>:
    __builtin_prefetch (obj);
    <D.20707>:
    <D.20698>:
  }
  <D.20653>:
}


sgen_safe_object_get_size (struct MonoObject * obj)
{
  char * iftmp.35;
  long unsigned int D.20723;
  long unsigned int D.20724;
  long unsigned int D.20727;
  guint D.20731;
  struct MonoVTable * D.20732;
  char * forwarded;

  D.20723 = MEM[(mword *)obj];
  D.20724 = D.20723 & 1;
  if (D.20724 != 0) goto <D.20725>; else goto <D.20726>;
  <D.20725>:
  D.20723 = MEM[(mword *)obj];
  D.20727 = D.20723 & 18446744073709551612;
  iftmp.35 = (char *) D.20727;
  goto <D.20728>;
  <D.20726>:
  iftmp.35 = 0B;
  <D.20728>:
  forwarded = iftmp.35;
  if (forwarded != 0B) goto <D.20729>; else goto <D.20730>;
  <D.20729>:
  obj = forwarded;
  <D.20730>:
  D.20723 = MEM[(mword *)obj];
  D.20727 = D.20723 & 18446744073709551612;
  D.20732 = (struct MonoVTable *) D.20727;
  D.20731 = sgen_par_object_get_size (D.20732, obj);
  return D.20731;
}


sgen_par_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  void * D.20734;
  long unsigned int D.20735;
  guint D.20740;
  int D.20741;
  int D.20742;
  unsigned int D.20743;
  long unsigned int D.20746;
  int D.20747;
  unsigned int D.20748;
  unsigned int element_size.36;
  unsigned int D.20750;
  long unsigned int D.20751;
  long unsigned int D.20752;
  struct MonoClass * D.20755;
  unsigned char D.20756;
  long unsigned int D.20757;
  long unsigned int D.20758;
  mword descr;
  mword type;

  D.20734 = vtable->gc_descr;
  descr = (mword) D.20734;
  type = descr & 7;
  D.20735 = type + 18446744073709551615;
  if (D.20735 <= 1) goto <D.20736>; else goto <D.20737>;
  <D.20736>:
  {
    mword size;

    size = descr & 65528;
    if (size == 0) goto <D.20738>; else goto <D.20739>;
    <D.20738>:
    D.20741 = MEM[(struct MonoString *)o].length;
    D.20742 = D.20741 * 2;
    D.20743 = (unsigned int) D.20742;
    D.20740 = D.20743 + 26;
    return D.20740;
    <D.20739>:
    D.20740 = (guint) size;
    return D.20740;
  }
  <D.20737>:
  if (type == 4) goto <D.20744>; else goto <D.20745>;
  <D.20744>:
  {
    int element_size;
    struct MonoArray * array;
    size_t size;

    D.20746 = descr >> 3;
    D.20747 = (int) D.20746;
    element_size = D.20747 & 1023;
    array = o;
    D.20748 = array->max_length;
    element_size.36 = (unsigned int) element_size;
    D.20750 = D.20748 * element_size.36;
    D.20751 = (long unsigned int) D.20750;
    size = D.20751 + 32;
    D.20752 = descr & 8192;
    if (D.20752 != 0) goto <D.20753>; else goto <D.20754>;
    <D.20753>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.20755 = vtable->klass;
    D.20756 = D.20755->rank;
    D.20757 = (long unsigned int) D.20756;
    D.20758 = D.20757 * 8;
    size = D.20758 + size;
    <D.20754>:
    D.20740 = (guint) size;
    return D.20740;
  }
  <D.20745>:
  D.20740 = slow_object_get_size (vtable, o);
  return D.20740;
}


slow_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  struct MonoClass * D.20760;
  guint D.20763;
  int D.20764;
  int D.20765;
  unsigned int D.20766;
  unsigned char D.20767;
  int D.20770;
  unsigned int D.20771;
  unsigned int D.20772;
  unsigned int D.20773;
  long unsigned int D.20774;
  struct MonoArrayBounds * D.20775;
  _Bool D.20776;
  long int D.20777;
  long int D.20778;
  long unsigned int D.20781;
  long unsigned int D.20782;
  int D.20783;
  struct MonoClass * klass;

  klass = vtable->klass;
  D.20760 = mono_defaults.string_class;
  if (D.20760 == klass) goto <D.20761>; else goto <D.20762>;
  <D.20761>:
  D.20764 = MEM[(struct MonoString *)o].length;
  D.20765 = D.20764 * 2;
  D.20766 = (unsigned int) D.20765;
  D.20763 = D.20766 + 26;
  return D.20763;
  <D.20762>:
  D.20767 = klass->rank;
  if (D.20767 != 0) goto <D.20768>; else goto <D.20769>;
  <D.20768>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.20770 = klass->sizes.element_size;
    D.20771 = (unsigned int) D.20770;
    D.20772 = array->max_length;
    D.20773 = D.20771 * D.20772;
    D.20774 = (long unsigned int) D.20773;
    size = D.20774 + 32;
    D.20775 = array->bounds;
    D.20776 = D.20775 != 0B;
    D.20777 = (long int) D.20776;
    D.20778 = __builtin_expect (D.20777, 0);
    if (D.20778 != 0) goto <D.20779>; else goto <D.20780>;
    <D.20779>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.20767 = klass->rank;
    D.20781 = (long unsigned int) D.20767;
    D.20782 = D.20781 * 8;
    size = D.20782 + size;
    <D.20780>:
    D.20763 = (guint) size;
    return D.20763;
  }
  <D.20769>:
  D.20783 = klass->instance_size;
  D.20763 = (guint) D.20783;
  return D.20763;
}


sgen_gc_descr_has_references (mword desc)
{
  long unsigned int D.20785;
  gboolean D.20788;
  long unsigned int D.20789;
  long unsigned int D.20792;

  D.20785 = desc & 4294901767;
  if (D.20785 == 1) goto <D.20786>; else goto <D.20787>;
  <D.20786>:
  D.20788 = 0;
  return D.20788;
  <D.20787>:
  D.20789 = desc & 49159;
  if (D.20789 == 4) goto <D.20790>; else goto <D.20791>;
  <D.20790>:
  D.20788 = 0;
  return D.20788;
  <D.20791>:
  D.20792 = desc & 7;
  if (D.20792 == 7) goto <D.20793>; else goto <D.20794>;
  <D.20793>:
  D.20788 = 0;
  return D.20788;
  <D.20794>:
  D.20788 = 1;
  return D.20788;
}


sgen_ptr_in_nursery (void * p)
{
  gboolean D.20796;
  int sgen_nursery_bits.37;
  int D.20798;
  int D.20799;
  long unsigned int D.20800;
  long unsigned int p.38;
  long unsigned int D.20802;
  char * sgen_nursery_start.39;
  long unsigned int sgen_nursery_start.40;
  _Bool D.20805;

  sgen_nursery_bits.37 = sgen_nursery_bits;
  D.20798 = 1 << sgen_nursery_bits.37;
  D.20799 = -D.20798;
  D.20800 = (long unsigned int) D.20799;
  p.38 = (long unsigned int) p;
  D.20802 = D.20800 & p.38;
  sgen_nursery_start.39 = sgen_nursery_start;
  sgen_nursery_start.40 = (long unsigned int) sgen_nursery_start.39;
  D.20805 = D.20802 == sgen_nursery_start.40;
  D.20796 = (gboolean) D.20805;
  return D.20796;
}


major_scan_object_concurrent (char * start, struct SgenGrayQueue * queue)
{
  long unsigned int D.20807;
  long unsigned int D.20808;
  long unsigned int D.20809;
  long unsigned int D.20810;
  long unsigned int D.20813;
  long unsigned int D.20814;
  long unsigned int D.20815;
  long unsigned int D.20816;
  long unsigned int D.20817;
  long unsigned int D.20818;
  int D.20822;
  void * D.20828;
  struct FILE * gc_debug_file.41;
  int iftmp.42;
  int D.20833;
  int D.20835;
  _Bool D.20837;
  long int D.20838;
  long int D.20839;
  int iftmp.43;
  int D.20845;
  int D.20847;
  _Bool D.20849;
  long int D.20850;
  long int D.20851;
  int D.20857;
  int iftmp.44;
  int D.20866;
  int D.20868;
  _Bool D.20870;
  long int D.20871;
  long int D.20872;
  int iftmp.45;
  int D.20878;
  int D.20880;
  _Bool D.20882;
  long int D.20883;
  long int D.20884;
  long unsigned int D.20887;
  long unsigned int D.20888;
  int D.20889;
  int D.20893;
  void * D.20899;
  int iftmp.46;
  int D.20903;
  int D.20905;
  _Bool D.20907;
  long int D.20908;
  long int D.20909;
  int iftmp.47;
  int D.20915;
  int D.20917;
  _Bool D.20919;
  long int D.20920;
  long int D.20921;
  long unsigned int D.20924;
  long unsigned int D.20925;
  int D.20926;
  int D.20930;
  int iftmp.48;
  int D.20939;
  int D.20941;
  _Bool D.20943;
  long int D.20944;
  long int D.20945;
  int iftmp.49;
  int D.20951;
  int D.20953;
  _Bool D.20955;
  long int D.20956;
  long int D.20957;
  long unsigned int D.20960;
  long unsigned int D.20963;
  int D.20964;
  int D.20965;
  unsigned int D.20968;
  unsigned int el_size.50;
  unsigned int D.20970;
  sizetype D.20971;
  int D.20975;
  void * D.20981;
  int iftmp.51;
  int D.20985;
  int D.20987;
  _Bool D.20989;
  long int D.20990;
  long int D.20991;
  int iftmp.52;
  int D.20997;
  int D.20999;
  _Bool D.21001;
  long int D.21002;
  long int D.21003;
  int D.21009;
  int D.21010;
  long unsigned int D.21011;
  long unsigned int D.21012;
  long unsigned int D.21013;
  long unsigned int D.21014;
  void * * D.21015;
  int D.21019;
  void * D.21025;
  int iftmp.53;
  int D.21029;
  void * D.21031;
  int D.21032;
  _Bool D.21034;
  long int D.21035;
  long int D.21036;
  void * D.21039;
  int iftmp.54;
  int D.21043;
  int D.21045;
  _Bool D.21047;
  long int D.21048;
  long int D.21049;
  sizetype D.21052;
  long unsigned int D.21056;
  int D.21062;
  void * D.21068;
  int iftmp.55;
  int D.21072;
  int D.21074;
  _Bool D.21076;
  long int D.21077;
  long int D.21078;
  int iftmp.56;
  int D.21084;
  int D.21086;
  _Bool D.21088;
  long int D.21089;
  long int D.21090;
  long unsigned int D.21093;
  int D.21099;
  void * D.21105;
  int iftmp.57;
  int D.21109;
  int D.21111;
  _Bool D.21113;
  long int D.21114;
  long int D.21115;
  int iftmp.58;
  int D.21121;
  int D.21123;
  _Bool D.21125;
  long int D.21126;
  long int D.21127;
  long unsigned int D.21130;
  unsigned int D.21131;
  unsigned int D.21132;
  struct MonoVTable * D.21135;
  struct MonoClass * D.21136;
  const char * D.21137;
  const char * D.21138;
  gsize * bitmap_data.59;
  long unsigned int D.21140;
  int D.21146;
  void * D.21152;
  int iftmp.60;
  int D.21156;
  int D.21158;
  _Bool D.21160;
  long int D.21161;
  long int D.21162;
  int iftmp.61;
  int D.21168;
  int D.21170;
  _Bool D.21172;
  long int D.21173;
  long int D.21174;
  int bwords.62;
  long unsigned int D.21178;
  gsize * mbitmap_data.63;
  long unsigned int D.21180;
  unsigned int D.21181;
  unsigned int D.21182;
  struct MonoClass * D.21183;
  unsigned int el_size.64;
  unsigned int D.21185;
  sizetype D.21186;
  const char * D.21189;
  const char * D.21190;
  gsize * bitmap_data.65;
  long unsigned int D.21192;
  int D.21198;
  void * D.21204;
  int iftmp.66;
  int D.21208;
  int D.21210;
  _Bool D.21212;
  long int D.21213;
  long int D.21214;
  int iftmp.67;
  int D.21220;
  int D.21222;
  _Bool D.21224;
  long int D.21225;
  long int D.21226;
  unsigned int bwords.68;
  sizetype D.21230;

  {
    struct GCVTable * vt;
    mword desc;

    D.20807 = MEM[(mword *)start];
    D.20808 = D.20807 & 18446744073709551612;
    vt = (struct GCVTable *) D.20808;
    desc = vt->desc;
    D.20809 = desc & 7;
    switch (D.20809) <default: <D.19819>, case 1: <D.19714>, case 2: <D.19725>, case 3: <D.19781>, case 4: <D.19737>, case 5: <D.19773>, case 6: <D.19796>, case 7: <D.19818>>
    <D.19714>:
    D.20810 = desc & 4294901760;
    if (D.20810 != 0) goto <D.20811>; else goto <D.20812>;
    <D.20811>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.20813 = desc >> 16;
      D.20814 = D.20813 & 255;
      D.20815 = D.20814 * 8;
      _objptr = _objptr + D.20815;
      D.20816 = desc >> 24;
      D.20817 = D.20816 & 255;
      D.20818 = D.20817 * 8;
      _objptr_end = _objptr + D.20818;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.20821>; else goto <D.20819>;
        <D.20821>:
        D.20822 = sgen_ptr_in_nursery (__old);
        if (D.20822 == 0) goto <D.20823>; else goto <D.20819>;
        <D.20823>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.20824>; else goto <D.20825>;
        <D.20824>:
        if (__old != __copy) goto <D.20826>; else goto <D.20827>;
        <D.20826>:
        D.20828 = *_objptr;
        gc_debug_file.41 = gc_debug_file;
        fprintf (gc_debug_file.41, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20828, __old);
        gc_debug_file.41 = gc_debug_file;
        fflush (gc_debug_file.41);
        <D.20827>:
        <D.20825>:
        D.20833 = sgen_ptr_in_nursery (__copy);
        if (D.20833 != 0) goto <D.20834>; else goto <D.20831>;
        <D.20834>:
        D.20835 = sgen_ptr_in_nursery (_objptr);
        if (D.20835 == 0) goto <D.20836>; else goto <D.20831>;
        <D.20836>:
        iftmp.42 = 1;
        goto <D.20832>;
        <D.20831>:
        iftmp.42 = 0;
        <D.20832>:
        D.20837 = iftmp.42 != 0;
        D.20838 = (long int) D.20837;
        D.20839 = __builtin_expect (D.20838, 0);
        if (D.20839 != 0) goto <D.20840>; else goto <D.20841>;
        <D.20840>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20841>:
        goto <D.20820>;
        <D.20819>:
        D.20845 = sgen_ptr_in_nursery (__old);
        if (D.20845 != 0) goto <D.20846>; else goto <D.20843>;
        <D.20846>:
        D.20847 = sgen_ptr_in_nursery (_objptr);
        if (D.20847 == 0) goto <D.20848>; else goto <D.20843>;
        <D.20848>:
        iftmp.43 = 1;
        goto <D.20844>;
        <D.20843>:
        iftmp.43 = 0;
        <D.20844>:
        D.20849 = iftmp.43 != 0;
        D.20850 = (long int) D.20849;
        D.20851 = __builtin_expect (D.20850, 0);
        if (D.20851 != 0) goto <D.20852>; else goto <D.20853>;
        <D.20852>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.20853>:
        <D.20820>:
      }
      _objptr = _objptr + 8;
      goto <D.19722>;
      <D.19721>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.20856>; else goto <D.20854>;
        <D.20856>:
        D.20857 = sgen_ptr_in_nursery (__old);
        if (D.20857 == 0) goto <D.20858>; else goto <D.20854>;
        <D.20858>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.20859>; else goto <D.20860>;
        <D.20859>:
        if (__old != __copy) goto <D.20861>; else goto <D.20862>;
        <D.20861>:
        D.20828 = *_objptr;
        gc_debug_file.41 = gc_debug_file;
        fprintf (gc_debug_file.41, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20828, __old);
        gc_debug_file.41 = gc_debug_file;
        fflush (gc_debug_file.41);
        <D.20862>:
        <D.20860>:
        D.20866 = sgen_ptr_in_nursery (__copy);
        if (D.20866 != 0) goto <D.20867>; else goto <D.20864>;
        <D.20867>:
        D.20868 = sgen_ptr_in_nursery (_objptr);
        if (D.20868 == 0) goto <D.20869>; else goto <D.20864>;
        <D.20869>:
        iftmp.44 = 1;
        goto <D.20865>;
        <D.20864>:
        iftmp.44 = 0;
        <D.20865>:
        D.20870 = iftmp.44 != 0;
        D.20871 = (long int) D.20870;
        D.20872 = __builtin_expect (D.20871, 0);
        if (D.20872 != 0) goto <D.20873>; else goto <D.20874>;
        <D.20873>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20874>:
        goto <D.20855>;
        <D.20854>:
        D.20878 = sgen_ptr_in_nursery (__old);
        if (D.20878 != 0) goto <D.20879>; else goto <D.20876>;
        <D.20879>:
        D.20880 = sgen_ptr_in_nursery (_objptr);
        if (D.20880 == 0) goto <D.20881>; else goto <D.20876>;
        <D.20881>:
        iftmp.45 = 1;
        goto <D.20877>;
        <D.20876>:
        iftmp.45 = 0;
        <D.20877>:
        D.20882 = iftmp.45 != 0;
        D.20883 = (long int) D.20882;
        D.20884 = __builtin_expect (D.20883, 0);
        if (D.20884 != 0) goto <D.20885>; else goto <D.20886>;
        <D.20885>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.20886>:
        <D.20855>:
      }
      _objptr = _objptr + 8;
      <D.19722>:
      if (_objptr < _objptr_end) goto <D.19721>; else goto <D.19723>;
      <D.19723>:
    }
    <D.20812>:
    goto <D.19724>;
    <D.19725>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 16;
      _objptr = _objptr + 16;
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.20887 = (long unsigned int) _index;
        D.20888 = D.20887 * 8;
        _objptr = _objptr + D.20888;
        D.20889 = _index + 1;
        _bmap = _bmap >> D.20889;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.20892>; else goto <D.20890>;
          <D.20892>:
          D.20893 = sgen_ptr_in_nursery (__old);
          if (D.20893 == 0) goto <D.20894>; else goto <D.20890>;
          <D.20894>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object_concurrent (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.20895>; else goto <D.20896>;
          <D.20895>:
          if (__old != __copy) goto <D.20897>; else goto <D.20898>;
          <D.20897>:
          D.20899 = *_objptr;
          gc_debug_file.41 = gc_debug_file;
          fprintf (gc_debug_file.41, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20899, __old);
          gc_debug_file.41 = gc_debug_file;
          fflush (gc_debug_file.41);
          <D.20898>:
          <D.20896>:
          D.20903 = sgen_ptr_in_nursery (__copy);
          if (D.20903 != 0) goto <D.20904>; else goto <D.20901>;
          <D.20904>:
          D.20905 = sgen_ptr_in_nursery (_objptr);
          if (D.20905 == 0) goto <D.20906>; else goto <D.20901>;
          <D.20906>:
          iftmp.46 = 1;
          goto <D.20902>;
          <D.20901>:
          iftmp.46 = 0;
          <D.20902>:
          D.20907 = iftmp.46 != 0;
          D.20908 = (long int) D.20907;
          D.20909 = __builtin_expect (D.20908, 0);
          if (D.20909 != 0) goto <D.20910>; else goto <D.20911>;
          <D.20910>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.20911>:
          goto <D.20891>;
          <D.20890>:
          D.20915 = sgen_ptr_in_nursery (__old);
          if (D.20915 != 0) goto <D.20916>; else goto <D.20913>;
          <D.20916>:
          D.20917 = sgen_ptr_in_nursery (_objptr);
          if (D.20917 == 0) goto <D.20918>; else goto <D.20913>;
          <D.20918>:
          iftmp.47 = 1;
          goto <D.20914>;
          <D.20913>:
          iftmp.47 = 0;
          <D.20914>:
          D.20919 = iftmp.47 != 0;
          D.20920 = (long int) D.20919;
          D.20921 = __builtin_expect (D.20920, 0);
          if (D.20921 != 0) goto <D.20922>; else goto <D.20923>;
          <D.20922>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.20923>:
          <D.20891>:
        }
        _objptr = _objptr + 8;
      }
      goto <D.19735>;
      <D.19734>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.20924 = (long unsigned int) _index;
        D.20925 = D.20924 * 8;
        _objptr = _objptr + D.20925;
        D.20926 = _index + 1;
        _bmap = _bmap >> D.20926;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.20929>; else goto <D.20927>;
          <D.20929>:
          D.20930 = sgen_ptr_in_nursery (__old);
          if (D.20930 == 0) goto <D.20931>; else goto <D.20927>;
          <D.20931>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object_concurrent (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.20932>; else goto <D.20933>;
          <D.20932>:
          if (__old != __copy) goto <D.20934>; else goto <D.20935>;
          <D.20934>:
          D.20899 = *_objptr;
          gc_debug_file.41 = gc_debug_file;
          fprintf (gc_debug_file.41, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20899, __old);
          gc_debug_file.41 = gc_debug_file;
          fflush (gc_debug_file.41);
          <D.20935>:
          <D.20933>:
          D.20939 = sgen_ptr_in_nursery (__copy);
          if (D.20939 != 0) goto <D.20940>; else goto <D.20937>;
          <D.20940>:
          D.20941 = sgen_ptr_in_nursery (_objptr);
          if (D.20941 == 0) goto <D.20942>; else goto <D.20937>;
          <D.20942>:
          iftmp.48 = 1;
          goto <D.20938>;
          <D.20937>:
          iftmp.48 = 0;
          <D.20938>:
          D.20943 = iftmp.48 != 0;
          D.20944 = (long int) D.20943;
          D.20945 = __builtin_expect (D.20944, 0);
          if (D.20945 != 0) goto <D.20946>; else goto <D.20947>;
          <D.20946>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.20947>:
          goto <D.20928>;
          <D.20927>:
          D.20951 = sgen_ptr_in_nursery (__old);
          if (D.20951 != 0) goto <D.20952>; else goto <D.20949>;
          <D.20952>:
          D.20953 = sgen_ptr_in_nursery (_objptr);
          if (D.20953 == 0) goto <D.20954>; else goto <D.20949>;
          <D.20954>:
          iftmp.49 = 1;
          goto <D.20950>;
          <D.20949>:
          iftmp.49 = 0;
          <D.20950>:
          D.20955 = iftmp.49 != 0;
          D.20956 = (long int) D.20955;
          D.20957 = __builtin_expect (D.20956, 0);
          if (D.20957 != 0) goto <D.20958>; else goto <D.20959>;
          <D.20958>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.20959>:
          <D.20928>:
        }
        _objptr = _objptr + 8;
      }
      <D.19735>:
      if (_bmap != 0) goto <D.19734>; else goto <D.19736>;
      <D.19736>:
    }
    goto <D.19724>;
    <D.19737>:
    D.20960 = desc & 4294950912;
    if (D.20960 != 0) goto <D.20961>; else goto <D.20962>;
    <D.20961>:
    {
      int el_size;
      int etype;

      D.20963 = desc >> 3;
      D.20964 = (int) D.20963;
      el_size = D.20964 & 1023;
      D.20965 = (int) desc;
      etype = D.20965 & 49152;
      if (etype == 16384) goto <D.20966>; else goto <D.20967>;
      <D.20966>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.20968 = MEM[(struct MonoArray *)start].max_length;
        el_size.50 = (unsigned int) el_size;
        D.20970 = D.20968 * el_size.50;
        D.20971 = (sizetype) D.20970;
        end_refs = p + D.20971;
        goto <D.19745>;
        <D.19744>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.20974>; else goto <D.20972>;
          <D.20974>:
          D.20975 = sgen_ptr_in_nursery (__old);
          if (D.20975 == 0) goto <D.20976>; else goto <D.20972>;
          <D.20976>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object_concurrent (p, __old, queue);
          __copy = *p;
          if (0 != 0) goto <D.20977>; else goto <D.20978>;
          <D.20977>:
          if (__old != __copy) goto <D.20979>; else goto <D.20980>;
          <D.20979>:
          D.20981 = *p;
          gc_debug_file.41 = gc_debug_file;
          fprintf (gc_debug_file.41, "Overwrote field at %p with %p (was: %p)\n", p, D.20981, __old);
          gc_debug_file.41 = gc_debug_file;
          fflush (gc_debug_file.41);
          <D.20980>:
          <D.20978>:
          D.20985 = sgen_ptr_in_nursery (__copy);
          if (D.20985 != 0) goto <D.20986>; else goto <D.20983>;
          <D.20986>:
          D.20987 = sgen_ptr_in_nursery (p);
          if (D.20987 == 0) goto <D.20988>; else goto <D.20983>;
          <D.20988>:
          iftmp.51 = 1;
          goto <D.20984>;
          <D.20983>:
          iftmp.51 = 0;
          <D.20984>:
          D.20989 = iftmp.51 != 0;
          D.20990 = (long int) D.20989;
          D.20991 = __builtin_expect (D.20990, 0);
          if (D.20991 != 0) goto <D.20992>; else goto <D.20993>;
          <D.20992>:
          sgen_add_to_global_remset (p, __copy);
          <D.20993>:
          goto <D.20973>;
          <D.20972>:
          D.20997 = sgen_ptr_in_nursery (__old);
          if (D.20997 != 0) goto <D.20998>; else goto <D.20995>;
          <D.20998>:
          D.20999 = sgen_ptr_in_nursery (p);
          if (D.20999 == 0) goto <D.21000>; else goto <D.20995>;
          <D.21000>:
          iftmp.52 = 1;
          goto <D.20996>;
          <D.20995>:
          iftmp.52 = 0;
          <D.20996>:
          D.21001 = iftmp.52 != 0;
          D.21002 = (long int) D.21001;
          D.21003 = __builtin_expect (D.21002, 0);
          if (D.21003 != 0) goto <D.21004>; else goto <D.21005>;
          <D.21004>:
          sgen_add_to_global_remset (p, __old);
          <D.21005>:
          <D.20973>:
        }
        p = p + 8;
        <D.19745>:
        if (p < end_refs) goto <D.19744>; else goto <D.19746>;
        <D.19746>:
      }
      goto <D.21006>;
      <D.20967>:
      if (etype == 32768) goto <D.21007>; else goto <D.21008>;
      <D.21007>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.20813 = desc >> 16;
        D.21009 = (int) D.20813;
        offset = D.21009 & 255;
        D.20816 = desc >> 24;
        D.21010 = (int) D.20816;
        num_refs = D.21010 & 255;
        e_start = start + 32;
        D.20968 = MEM[(struct MonoArray *)start].max_length;
        el_size.50 = (unsigned int) el_size;
        D.20970 = D.20968 * el_size.50;
        D.20971 = (sizetype) D.20970;
        e_end = e_start + D.20971;
        goto <D.19759>;
        <D.19758>:
        {
          void * * p;
          int i;

          p = e_start;
          D.21011 = (long unsigned int) offset;
          D.21012 = D.21011 * 8;
          p = p + D.21012;
          i = 0;
          goto <D.19756>;
          <D.19755>:
          {
            void * __old;
            void * __copy;

            D.21013 = (long unsigned int) i;
            D.21014 = D.21013 * 8;
            D.21015 = p + D.21014;
            __old = *D.21015;
            if (__old != 0B) goto <D.21018>; else goto <D.21016>;
            <D.21018>:
            D.21019 = sgen_ptr_in_nursery (__old);
            if (D.21019 == 0) goto <D.21020>; else goto <D.21016>;
            <D.21020>:
            __builtin_prefetch (__old);
            D.21013 = (long unsigned int) i;
            D.21014 = D.21013 * 8;
            D.21015 = p + D.21014;
            major_copy_or_mark_object_concurrent (D.21015, __old, queue);
            D.21013 = (long unsigned int) i;
            D.21014 = D.21013 * 8;
            D.21015 = p + D.21014;
            __copy = *D.21015;
            if (0 != 0) goto <D.21021>; else goto <D.21022>;
            <D.21021>:
            if (__old != __copy) goto <D.21023>; else goto <D.21024>;
            <D.21023>:
            D.21013 = (long unsigned int) i;
            D.21014 = D.21013 * 8;
            D.21015 = p + D.21014;
            D.21025 = *D.21015;
            D.21013 = (long unsigned int) i;
            D.21014 = D.21013 * 8;
            D.21015 = p + D.21014;
            gc_debug_file.41 = gc_debug_file;
            fprintf (gc_debug_file.41, "Overwrote field at %p with %p (was: %p)\n", D.21015, D.21025, __old);
            gc_debug_file.41 = gc_debug_file;
            fflush (gc_debug_file.41);
            <D.21024>:
            <D.21022>:
            D.21029 = sgen_ptr_in_nursery (__copy);
            if (D.21029 != 0) goto <D.21030>; else goto <D.21027>;
            <D.21030>:
            D.21013 = (long unsigned int) i;
            D.21014 = D.21013 * 8;
            D.21031 = p + D.21014;
            D.21032 = sgen_ptr_in_nursery (D.21031);
            if (D.21032 == 0) goto <D.21033>; else goto <D.21027>;
            <D.21033>:
            iftmp.53 = 1;
            goto <D.21028>;
            <D.21027>:
            iftmp.53 = 0;
            <D.21028>:
            D.21034 = iftmp.53 != 0;
            D.21035 = (long int) D.21034;
            D.21036 = __builtin_expect (D.21035, 0);
            if (D.21036 != 0) goto <D.21037>; else goto <D.21038>;
            <D.21037>:
            D.21013 = (long unsigned int) i;
            D.21014 = D.21013 * 8;
            D.21039 = p + D.21014;
            sgen_add_to_global_remset (D.21039, __copy);
            <D.21038>:
            goto <D.21017>;
            <D.21016>:
            D.21043 = sgen_ptr_in_nursery (__old);
            if (D.21043 != 0) goto <D.21044>; else goto <D.21041>;
            <D.21044>:
            D.21013 = (long unsigned int) i;
            D.21014 = D.21013 * 8;
            D.21031 = p + D.21014;
            D.21045 = sgen_ptr_in_nursery (D.21031);
            if (D.21045 == 0) goto <D.21046>; else goto <D.21041>;
            <D.21046>:
            iftmp.54 = 1;
            goto <D.21042>;
            <D.21041>:
            iftmp.54 = 0;
            <D.21042>:
            D.21047 = iftmp.54 != 0;
            D.21048 = (long int) D.21047;
            D.21049 = __builtin_expect (D.21048, 0);
            if (D.21049 != 0) goto <D.21050>; else goto <D.21051>;
            <D.21050>:
            D.21013 = (long unsigned int) i;
            D.21014 = D.21013 * 8;
            D.21039 = p + D.21014;
            sgen_add_to_global_remset (D.21039, __old);
            <D.21051>:
            <D.21017>:
          }
          i = i + 1;
          <D.19756>:
          if (i < num_refs) goto <D.19755>; else goto <D.19757>;
          <D.19757>:
          D.21052 = (sizetype) el_size;
          e_start = e_start + D.21052;
        }
        <D.19759>:
        if (e_start < e_end) goto <D.19758>; else goto <D.19760>;
        <D.19760>:
      }
      goto <D.21053>;
      <D.21008>:
      if (etype == 49152) goto <D.21054>; else goto <D.21055>;
      <D.21054>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.20968 = MEM[(struct MonoArray *)start].max_length;
        el_size.50 = (unsigned int) el_size;
        D.20970 = D.20968 * el_size.50;
        D.20971 = (sizetype) D.20970;
        e_end = e_start + D.20971;
        goto <D.19771>;
        <D.19770>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.19768>;
          <D.19767>:
          D.21056 = _bmap & 1;
          if (D.21056 != 0) goto <D.21057>; else goto <D.21058>;
          <D.21057>:
          {
            void * __old;
            void * __copy;

            __old = *p;
            if (__old != 0B) goto <D.21061>; else goto <D.21059>;
            <D.21061>:
            D.21062 = sgen_ptr_in_nursery (__old);
            if (D.21062 == 0) goto <D.21063>; else goto <D.21059>;
            <D.21063>:
            __builtin_prefetch (__old);
            major_copy_or_mark_object_concurrent (p, __old, queue);
            __copy = *p;
            if (0 != 0) goto <D.21064>; else goto <D.21065>;
            <D.21064>:
            if (__old != __copy) goto <D.21066>; else goto <D.21067>;
            <D.21066>:
            D.21068 = *p;
            gc_debug_file.41 = gc_debug_file;
            fprintf (gc_debug_file.41, "Overwrote field at %p with %p (was: %p)\n", p, D.21068, __old);
            gc_debug_file.41 = gc_debug_file;
            fflush (gc_debug_file.41);
            <D.21067>:
            <D.21065>:
            D.21072 = sgen_ptr_in_nursery (__copy);
            if (D.21072 != 0) goto <D.21073>; else goto <D.21070>;
            <D.21073>:
            D.21074 = sgen_ptr_in_nursery (p);
            if (D.21074 == 0) goto <D.21075>; else goto <D.21070>;
            <D.21075>:
            iftmp.55 = 1;
            goto <D.21071>;
            <D.21070>:
            iftmp.55 = 0;
            <D.21071>:
            D.21076 = iftmp.55 != 0;
            D.21077 = (long int) D.21076;
            D.21078 = __builtin_expect (D.21077, 0);
            if (D.21078 != 0) goto <D.21079>; else goto <D.21080>;
            <D.21079>:
            sgen_add_to_global_remset (p, __copy);
            <D.21080>:
            goto <D.21060>;
            <D.21059>:
            D.21084 = sgen_ptr_in_nursery (__old);
            if (D.21084 != 0) goto <D.21085>; else goto <D.21082>;
            <D.21085>:
            D.21086 = sgen_ptr_in_nursery (p);
            if (D.21086 == 0) goto <D.21087>; else goto <D.21082>;
            <D.21087>:
            iftmp.56 = 1;
            goto <D.21083>;
            <D.21082>:
            iftmp.56 = 0;
            <D.21083>:
            D.21088 = iftmp.56 != 0;
            D.21089 = (long int) D.21088;
            D.21090 = __builtin_expect (D.21089, 0);
            if (D.21090 != 0) goto <D.21091>; else goto <D.21092>;
            <D.21091>:
            sgen_add_to_global_remset (p, __old);
            <D.21092>:
            <D.21060>:
          }
          <D.21058>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.19768>:
          if (_bmap != 0) goto <D.19767>; else goto <D.19769>;
          <D.19769>:
          D.21052 = (sizetype) el_size;
          e_start = e_start + D.21052;
        }
        <D.19771>:
        if (e_start < e_end) goto <D.19770>; else goto <D.19772>;
        <D.19772>:
      }
      <D.21055>:
      <D.21053>:
      <D.21006>:
    }
    <D.20962>:
    goto <D.19724>;
    <D.19773>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.19779>;
      <D.19778>:
      D.21093 = _bmap & 1;
      if (D.21093 != 0) goto <D.21094>; else goto <D.21095>;
      <D.21094>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21098>; else goto <D.21096>;
        <D.21098>:
        D.21099 = sgen_ptr_in_nursery (__old);
        if (D.21099 == 0) goto <D.21100>; else goto <D.21096>;
        <D.21100>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21101>; else goto <D.21102>;
        <D.21101>:
        if (__old != __copy) goto <D.21103>; else goto <D.21104>;
        <D.21103>:
        D.21105 = *_objptr;
        gc_debug_file.41 = gc_debug_file;
        fprintf (gc_debug_file.41, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21105, __old);
        gc_debug_file.41 = gc_debug_file;
        fflush (gc_debug_file.41);
        <D.21104>:
        <D.21102>:
        D.21109 = sgen_ptr_in_nursery (__copy);
        if (D.21109 != 0) goto <D.21110>; else goto <D.21107>;
        <D.21110>:
        D.21111 = sgen_ptr_in_nursery (_objptr);
        if (D.21111 == 0) goto <D.21112>; else goto <D.21107>;
        <D.21112>:
        iftmp.57 = 1;
        goto <D.21108>;
        <D.21107>:
        iftmp.57 = 0;
        <D.21108>:
        D.21113 = iftmp.57 != 0;
        D.21114 = (long int) D.21113;
        D.21115 = __builtin_expect (D.21114, 0);
        if (D.21115 != 0) goto <D.21116>; else goto <D.21117>;
        <D.21116>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21117>:
        goto <D.21097>;
        <D.21096>:
        D.21121 = sgen_ptr_in_nursery (__old);
        if (D.21121 != 0) goto <D.21122>; else goto <D.21119>;
        <D.21122>:
        D.21123 = sgen_ptr_in_nursery (_objptr);
        if (D.21123 == 0) goto <D.21124>; else goto <D.21119>;
        <D.21124>:
        iftmp.58 = 1;
        goto <D.21120>;
        <D.21119>:
        iftmp.58 = 0;
        <D.21120>:
        D.21125 = iftmp.58 != 0;
        D.21126 = (long int) D.21125;
        D.21127 = __builtin_expect (D.21126, 0);
        if (D.21127 != 0) goto <D.21128>; else goto <D.21129>;
        <D.21128>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.21129>:
        <D.21097>:
      }
      <D.21095>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.19779>:
      if (_bmap != 0) goto <D.19778>; else goto <D.19780>;
      <D.19780>:
    }
    goto <D.19724>;
    <D.19781>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.21130 = *bitmap_data;
      D.21131 = (unsigned int) D.21130;
      D.21132 = D.21131 + 4294967295;
      bwords = (int) D.21132;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.21133>; else goto <D.21134>;
      <D.21133>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.21135 = myobj->vtable;
        D.21136 = D.21135->klass;
        D.21137 = D.21136->name;
        D.21135 = myobj->vtable;
        D.21136 = D.21135->klass;
        D.21138 = D.21136->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21138, D.21137);
      }
      <D.21134>:
      goto <D.19794>;
      <D.19793>:
      {
        gsize _bmap;

        bitmap_data.59 = bitmap_data;
        bitmap_data = bitmap_data.59 + 8;
        _bmap = *bitmap_data.59;
        _objptr = start_run;
        goto <D.19791>;
        <D.19790>:
        D.21140 = _bmap & 1;
        if (D.21140 != 0) goto <D.21141>; else goto <D.21142>;
        <D.21141>:
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21145>; else goto <D.21143>;
          <D.21145>:
          D.21146 = sgen_ptr_in_nursery (__old);
          if (D.21146 == 0) goto <D.21147>; else goto <D.21143>;
          <D.21147>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object_concurrent (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21148>; else goto <D.21149>;
          <D.21148>:
          if (__old != __copy) goto <D.21150>; else goto <D.21151>;
          <D.21150>:
          D.21152 = *_objptr;
          gc_debug_file.41 = gc_debug_file;
          fprintf (gc_debug_file.41, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21152, __old);
          gc_debug_file.41 = gc_debug_file;
          fflush (gc_debug_file.41);
          <D.21151>:
          <D.21149>:
          D.21156 = sgen_ptr_in_nursery (__copy);
          if (D.21156 != 0) goto <D.21157>; else goto <D.21154>;
          <D.21157>:
          D.21158 = sgen_ptr_in_nursery (_objptr);
          if (D.21158 == 0) goto <D.21159>; else goto <D.21154>;
          <D.21159>:
          iftmp.60 = 1;
          goto <D.21155>;
          <D.21154>:
          iftmp.60 = 0;
          <D.21155>:
          D.21160 = iftmp.60 != 0;
          D.21161 = (long int) D.21160;
          D.21162 = __builtin_expect (D.21161, 0);
          if (D.21162 != 0) goto <D.21163>; else goto <D.21164>;
          <D.21163>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21164>:
          goto <D.21144>;
          <D.21143>:
          D.21168 = sgen_ptr_in_nursery (__old);
          if (D.21168 != 0) goto <D.21169>; else goto <D.21166>;
          <D.21169>:
          D.21170 = sgen_ptr_in_nursery (_objptr);
          if (D.21170 == 0) goto <D.21171>; else goto <D.21166>;
          <D.21171>:
          iftmp.61 = 1;
          goto <D.21167>;
          <D.21166>:
          iftmp.61 = 0;
          <D.21167>:
          D.21172 = iftmp.61 != 0;
          D.21173 = (long int) D.21172;
          D.21174 = __builtin_expect (D.21173, 0);
          if (D.21174 != 0) goto <D.21175>; else goto <D.21176>;
          <D.21175>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.21176>:
          <D.21144>:
        }
        <D.21142>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.19791>:
        if (_bmap != 0) goto <D.19790>; else goto <D.19792>;
        <D.19792>:
        start_run = start_run + 512;
      }
      <D.19794>:
      bwords.62 = bwords;
      bwords = bwords.62 + -1;
      if (bwords.62 > 0) goto <D.19793>; else goto <D.19795>;
      <D.19795>:
    }
    goto <D.19724>;
    <D.19796>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.21178 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.21178);
      mbitmap_data.63 = mbitmap_data;
      mbitmap_data = mbitmap_data.63 + 8;
      D.21180 = *mbitmap_data.63;
      D.21181 = (unsigned int) D.21180;
      D.21182 = D.21181 + 4294967295;
      mbwords = (int) D.21182;
      D.21183 = vt->klass;
      el_size = mono_array_element_size (D.21183);
      e_start = start + 32;
      D.20968 = MEM[(struct MonoArray *)start].max_length;
      el_size.64 = (unsigned int) el_size;
      D.21185 = D.20968 * el_size.64;
      D.21186 = (sizetype) D.21185;
      e_end = e_start + D.21186;
      if (0 != 0) goto <D.21187>; else goto <D.21188>;
      <D.21187>:
      D.21183 = vt->klass;
      D.21189 = D.21183->name;
      D.21183 = vt->klass;
      D.21190 = D.21183->name_space;
      D.21178 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.21178, D.21190, D.21189);
      <D.21188>:
      goto <D.19816>;
      <D.19815>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.19813>;
        <D.19812>:
        {
          gsize _bmap;
          void * * start_run;

          bitmap_data.65 = bitmap_data;
          bitmap_data = bitmap_data.65 + 8;
          _bmap = *bitmap_data.65;
          start_run = _objptr;
          goto <D.19810>;
          <D.19809>:
          D.21192 = _bmap & 1;
          if (D.21192 != 0) goto <D.21193>; else goto <D.21194>;
          <D.21193>:
          {
            void * __old;
            void * __copy;

            __old = *_objptr;
            if (__old != 0B) goto <D.21197>; else goto <D.21195>;
            <D.21197>:
            D.21198 = sgen_ptr_in_nursery (__old);
            if (D.21198 == 0) goto <D.21199>; else goto <D.21195>;
            <D.21199>:
            __builtin_prefetch (__old);
            major_copy_or_mark_object_concurrent (_objptr, __old, queue);
            __copy = *_objptr;
            if (0 != 0) goto <D.21200>; else goto <D.21201>;
            <D.21200>:
            if (__old != __copy) goto <D.21202>; else goto <D.21203>;
            <D.21202>:
            D.21204 = *_objptr;
            gc_debug_file.41 = gc_debug_file;
            fprintf (gc_debug_file.41, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21204, __old);
            gc_debug_file.41 = gc_debug_file;
            fflush (gc_debug_file.41);
            <D.21203>:
            <D.21201>:
            D.21208 = sgen_ptr_in_nursery (__copy);
            if (D.21208 != 0) goto <D.21209>; else goto <D.21206>;
            <D.21209>:
            D.21210 = sgen_ptr_in_nursery (_objptr);
            if (D.21210 == 0) goto <D.21211>; else goto <D.21206>;
            <D.21211>:
            iftmp.66 = 1;
            goto <D.21207>;
            <D.21206>:
            iftmp.66 = 0;
            <D.21207>:
            D.21212 = iftmp.66 != 0;
            D.21213 = (long int) D.21212;
            D.21214 = __builtin_expect (D.21213, 0);
            if (D.21214 != 0) goto <D.21215>; else goto <D.21216>;
            <D.21215>:
            sgen_add_to_global_remset (_objptr, __copy);
            <D.21216>:
            goto <D.21196>;
            <D.21195>:
            D.21220 = sgen_ptr_in_nursery (__old);
            if (D.21220 != 0) goto <D.21221>; else goto <D.21218>;
            <D.21221>:
            D.21222 = sgen_ptr_in_nursery (_objptr);
            if (D.21222 == 0) goto <D.21223>; else goto <D.21218>;
            <D.21223>:
            iftmp.67 = 1;
            goto <D.21219>;
            <D.21218>:
            iftmp.67 = 0;
            <D.21219>:
            D.21224 = iftmp.67 != 0;
            D.21225 = (long int) D.21224;
            D.21226 = __builtin_expect (D.21225, 0);
            if (D.21226 != 0) goto <D.21227>; else goto <D.21228>;
            <D.21227>:
            sgen_add_to_global_remset (_objptr, __old);
            <D.21228>:
            <D.21196>:
          }
          <D.21194>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.19810>:
          if (_bmap != 0) goto <D.19809>; else goto <D.19811>;
          <D.19811>:
          _objptr = start_run + 512;
        }
        <D.19813>:
        bwords.68 = bwords;
        bwords = bwords.68 + 4294967295;
        if (bwords.68 != 0) goto <D.19812>; else goto <D.19814>;
        <D.19814>:
        D.21230 = (sizetype) el_size;
        e_start = e_start + D.21230;
      }
      <D.19816>:
      if (e_start < e_end) goto <D.19815>; else goto <D.19817>;
      <D.19817>:
    }
    goto <D.19724>;
    <D.19818>:
    goto <D.19724>;
    <D.19819>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.19724>:
  }
}


major_copy_or_mark_object_concurrent_canonical (void * * ptr, struct SgenGrayQueue * queue)
{
  void * D.21232;

  D.21232 = *ptr;
  major_copy_or_mark_object_concurrent (ptr, D.21232, queue);
}


major_scan_object (char * start, struct SgenGrayQueue * queue)
{
  long unsigned int D.21233;
  long unsigned int D.21234;
  long unsigned int D.21235;
  long unsigned int D.21236;
  long unsigned int D.21239;
  long unsigned int D.21240;
  long unsigned int D.21241;
  long unsigned int D.21242;
  long unsigned int D.21243;
  long unsigned int D.21244;
  void * D.21251;
  struct FILE * gc_debug_file.69;
  int iftmp.70;
  int D.21256;
  int D.21258;
  _Bool D.21260;
  long int D.21261;
  long int D.21262;
  int iftmp.71;
  int D.21277;
  int D.21279;
  _Bool D.21281;
  long int D.21282;
  long int D.21283;
  long unsigned int D.21289;
  long unsigned int D.21290;
  int D.21291;
  void * D.21298;
  int iftmp.72;
  int D.21302;
  int D.21304;
  _Bool D.21306;
  long int D.21307;
  long int D.21308;
  long unsigned int D.21314;
  long unsigned int D.21315;
  int D.21316;
  int iftmp.73;
  int D.21326;
  int D.21328;
  _Bool D.21330;
  long int D.21331;
  long int D.21332;
  long unsigned int D.21338;
  long unsigned int D.21341;
  int D.21342;
  int D.21343;
  unsigned int D.21346;
  unsigned int el_size.74;
  unsigned int D.21348;
  sizetype D.21349;
  void * D.21356;
  int iftmp.75;
  int D.21360;
  int D.21362;
  _Bool D.21364;
  long int D.21365;
  long int D.21366;
  int D.21375;
  int D.21376;
  long unsigned int D.21377;
  long unsigned int D.21378;
  long unsigned int D.21379;
  long unsigned int D.21380;
  void * * D.21381;
  void * D.21388;
  int iftmp.76;
  int D.21392;
  void * D.21394;
  int D.21395;
  _Bool D.21397;
  long int D.21398;
  long int D.21399;
  void * D.21402;
  sizetype D.21406;
  long unsigned int D.21410;
  void * D.21419;
  int iftmp.77;
  int D.21423;
  int D.21425;
  _Bool D.21427;
  long int D.21428;
  long int D.21429;
  long unsigned int D.21435;
  void * D.21444;
  int iftmp.78;
  int D.21448;
  int D.21450;
  _Bool D.21452;
  long int D.21453;
  long int D.21454;
  long unsigned int D.21460;
  unsigned int D.21461;
  unsigned int D.21462;
  struct MonoVTable * D.21465;
  struct MonoClass * D.21466;
  const char * D.21467;
  const char * D.21468;
  gsize * bitmap_data.79;
  long unsigned int D.21470;
  void * D.21479;
  int iftmp.80;
  int D.21483;
  int D.21485;
  _Bool D.21487;
  long int D.21488;
  long int D.21489;
  int bwords.81;
  long unsigned int D.21496;
  gsize * mbitmap_data.82;
  long unsigned int D.21498;
  unsigned int D.21499;
  unsigned int D.21500;
  struct MonoClass * D.21501;
  unsigned int el_size.83;
  unsigned int D.21503;
  sizetype D.21504;
  const char * D.21507;
  const char * D.21508;
  gsize * bitmap_data.84;
  long unsigned int D.21510;
  void * D.21519;
  int iftmp.85;
  int D.21523;
  int D.21525;
  _Bool D.21527;
  long int D.21528;
  long int D.21529;
  unsigned int bwords.86;
  sizetype D.21536;

  {
    struct GCVTable * vt;
    mword desc;

    D.21233 = MEM[(mword *)start];
    D.21234 = D.21233 & 18446744073709551612;
    vt = (struct GCVTable *) D.21234;
    desc = vt->desc;
    D.21235 = desc & 7;
    switch (D.21235) <default: <D.19706>, case 1: <D.19601>, case 2: <D.19612>, case 3: <D.19668>, case 4: <D.19624>, case 5: <D.19660>, case 6: <D.19683>, case 7: <D.19705>>
    <D.19601>:
    D.21236 = desc & 4294901760;
    if (D.21236 != 0) goto <D.21237>; else goto <D.21238>;
    <D.21237>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.21239 = desc >> 16;
      D.21240 = D.21239 & 255;
      D.21241 = D.21240 * 8;
      _objptr = _objptr + D.21241;
      D.21242 = desc >> 24;
      D.21243 = D.21242 & 255;
      D.21244 = D.21243 * 8;
      _objptr_end = _objptr + D.21244;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21245>; else goto <D.21246>;
        <D.21245>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21247>; else goto <D.21248>;
        <D.21247>:
        if (__old != __copy) goto <D.21249>; else goto <D.21250>;
        <D.21249>:
        D.21251 = *_objptr;
        gc_debug_file.69 = gc_debug_file;
        fprintf (gc_debug_file.69, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21251, __old);
        gc_debug_file.69 = gc_debug_file;
        fflush (gc_debug_file.69);
        <D.21250>:
        <D.21248>:
        D.21256 = sgen_ptr_in_nursery (__copy);
        if (D.21256 != 0) goto <D.21257>; else goto <D.21254>;
        <D.21257>:
        D.21258 = sgen_ptr_in_nursery (_objptr);
        if (D.21258 == 0) goto <D.21259>; else goto <D.21254>;
        <D.21259>:
        iftmp.70 = 1;
        goto <D.21255>;
        <D.21254>:
        iftmp.70 = 0;
        <D.21255>:
        D.21260 = iftmp.70 != 0;
        D.21261 = (long int) D.21260;
        D.21262 = __builtin_expect (D.21261, 0);
        if (D.21262 != 0) goto <D.21263>; else goto <D.21264>;
        <D.21263>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21264>:
        goto <D.21265>;
        <D.21246>:
        if (0 != 0) goto <D.21266>; else goto <D.21267>;
        <D.21266>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.21267>:
        <D.21265>:
      }
      _objptr = _objptr + 8;
      goto <D.19609>;
      <D.19608>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21268>; else goto <D.21269>;
        <D.21268>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21270>; else goto <D.21271>;
        <D.21270>:
        if (__old != __copy) goto <D.21272>; else goto <D.21273>;
        <D.21272>:
        D.21251 = *_objptr;
        gc_debug_file.69 = gc_debug_file;
        fprintf (gc_debug_file.69, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21251, __old);
        gc_debug_file.69 = gc_debug_file;
        fflush (gc_debug_file.69);
        <D.21273>:
        <D.21271>:
        D.21277 = sgen_ptr_in_nursery (__copy);
        if (D.21277 != 0) goto <D.21278>; else goto <D.21275>;
        <D.21278>:
        D.21279 = sgen_ptr_in_nursery (_objptr);
        if (D.21279 == 0) goto <D.21280>; else goto <D.21275>;
        <D.21280>:
        iftmp.71 = 1;
        goto <D.21276>;
        <D.21275>:
        iftmp.71 = 0;
        <D.21276>:
        D.21281 = iftmp.71 != 0;
        D.21282 = (long int) D.21281;
        D.21283 = __builtin_expect (D.21282, 0);
        if (D.21283 != 0) goto <D.21284>; else goto <D.21285>;
        <D.21284>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21285>:
        goto <D.21286>;
        <D.21269>:
        if (0 != 0) goto <D.21287>; else goto <D.21288>;
        <D.21287>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.21288>:
        <D.21286>:
      }
      _objptr = _objptr + 8;
      <D.19609>:
      if (_objptr < _objptr_end) goto <D.19608>; else goto <D.19610>;
      <D.19610>:
    }
    <D.21238>:
    goto <D.19611>;
    <D.19612>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 16;
      _objptr = _objptr + 16;
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.21289 = (long unsigned int) _index;
        D.21290 = D.21289 * 8;
        _objptr = _objptr + D.21290;
        D.21291 = _index + 1;
        _bmap = _bmap >> D.21291;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21292>; else goto <D.21293>;
          <D.21292>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21294>; else goto <D.21295>;
          <D.21294>:
          if (__old != __copy) goto <D.21296>; else goto <D.21297>;
          <D.21296>:
          D.21298 = *_objptr;
          gc_debug_file.69 = gc_debug_file;
          fprintf (gc_debug_file.69, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21298, __old);
          gc_debug_file.69 = gc_debug_file;
          fflush (gc_debug_file.69);
          <D.21297>:
          <D.21295>:
          D.21302 = sgen_ptr_in_nursery (__copy);
          if (D.21302 != 0) goto <D.21303>; else goto <D.21300>;
          <D.21303>:
          D.21304 = sgen_ptr_in_nursery (_objptr);
          if (D.21304 == 0) goto <D.21305>; else goto <D.21300>;
          <D.21305>:
          iftmp.72 = 1;
          goto <D.21301>;
          <D.21300>:
          iftmp.72 = 0;
          <D.21301>:
          D.21306 = iftmp.72 != 0;
          D.21307 = (long int) D.21306;
          D.21308 = __builtin_expect (D.21307, 0);
          if (D.21308 != 0) goto <D.21309>; else goto <D.21310>;
          <D.21309>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21310>:
          goto <D.21311>;
          <D.21293>:
          if (0 != 0) goto <D.21312>; else goto <D.21313>;
          <D.21312>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.21313>:
          <D.21311>:
        }
        _objptr = _objptr + 8;
      }
      goto <D.19622>;
      <D.19621>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.21314 = (long unsigned int) _index;
        D.21315 = D.21314 * 8;
        _objptr = _objptr + D.21315;
        D.21316 = _index + 1;
        _bmap = _bmap >> D.21316;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21317>; else goto <D.21318>;
          <D.21317>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21319>; else goto <D.21320>;
          <D.21319>:
          if (__old != __copy) goto <D.21321>; else goto <D.21322>;
          <D.21321>:
          D.21298 = *_objptr;
          gc_debug_file.69 = gc_debug_file;
          fprintf (gc_debug_file.69, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21298, __old);
          gc_debug_file.69 = gc_debug_file;
          fflush (gc_debug_file.69);
          <D.21322>:
          <D.21320>:
          D.21326 = sgen_ptr_in_nursery (__copy);
          if (D.21326 != 0) goto <D.21327>; else goto <D.21324>;
          <D.21327>:
          D.21328 = sgen_ptr_in_nursery (_objptr);
          if (D.21328 == 0) goto <D.21329>; else goto <D.21324>;
          <D.21329>:
          iftmp.73 = 1;
          goto <D.21325>;
          <D.21324>:
          iftmp.73 = 0;
          <D.21325>:
          D.21330 = iftmp.73 != 0;
          D.21331 = (long int) D.21330;
          D.21332 = __builtin_expect (D.21331, 0);
          if (D.21332 != 0) goto <D.21333>; else goto <D.21334>;
          <D.21333>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21334>:
          goto <D.21335>;
          <D.21318>:
          if (0 != 0) goto <D.21336>; else goto <D.21337>;
          <D.21336>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.21337>:
          <D.21335>:
        }
        _objptr = _objptr + 8;
      }
      <D.19622>:
      if (_bmap != 0) goto <D.19621>; else goto <D.19623>;
      <D.19623>:
    }
    goto <D.19611>;
    <D.19624>:
    D.21338 = desc & 4294950912;
    if (D.21338 != 0) goto <D.21339>; else goto <D.21340>;
    <D.21339>:
    {
      int el_size;
      int etype;

      D.21341 = desc >> 3;
      D.21342 = (int) D.21341;
      el_size = D.21342 & 1023;
      D.21343 = (int) desc;
      etype = D.21343 & 49152;
      if (etype == 16384) goto <D.21344>; else goto <D.21345>;
      <D.21344>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.21346 = MEM[(struct MonoArray *)start].max_length;
        el_size.74 = (unsigned int) el_size;
        D.21348 = D.21346 * el_size.74;
        D.21349 = (sizetype) D.21348;
        end_refs = p + D.21349;
        goto <D.19632>;
        <D.19631>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.21350>; else goto <D.21351>;
          <D.21350>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object (p, __old, queue);
          __copy = *p;
          if (0 != 0) goto <D.21352>; else goto <D.21353>;
          <D.21352>:
          if (__old != __copy) goto <D.21354>; else goto <D.21355>;
          <D.21354>:
          D.21356 = *p;
          gc_debug_file.69 = gc_debug_file;
          fprintf (gc_debug_file.69, "Overwrote field at %p with %p (was: %p)\n", p, D.21356, __old);
          gc_debug_file.69 = gc_debug_file;
          fflush (gc_debug_file.69);
          <D.21355>:
          <D.21353>:
          D.21360 = sgen_ptr_in_nursery (__copy);
          if (D.21360 != 0) goto <D.21361>; else goto <D.21358>;
          <D.21361>:
          D.21362 = sgen_ptr_in_nursery (p);
          if (D.21362 == 0) goto <D.21363>; else goto <D.21358>;
          <D.21363>:
          iftmp.75 = 1;
          goto <D.21359>;
          <D.21358>:
          iftmp.75 = 0;
          <D.21359>:
          D.21364 = iftmp.75 != 0;
          D.21365 = (long int) D.21364;
          D.21366 = __builtin_expect (D.21365, 0);
          if (D.21366 != 0) goto <D.21367>; else goto <D.21368>;
          <D.21367>:
          sgen_add_to_global_remset (p, __copy);
          <D.21368>:
          goto <D.21369>;
          <D.21351>:
          if (0 != 0) goto <D.21370>; else goto <D.21371>;
          <D.21370>:
          sgen_add_to_global_remset (p, __old);
          <D.21371>:
          <D.21369>:
        }
        p = p + 8;
        <D.19632>:
        if (p < end_refs) goto <D.19631>; else goto <D.19633>;
        <D.19633>:
      }
      goto <D.21372>;
      <D.21345>:
      if (etype == 32768) goto <D.21373>; else goto <D.21374>;
      <D.21373>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.21239 = desc >> 16;
        D.21375 = (int) D.21239;
        offset = D.21375 & 255;
        D.21242 = desc >> 24;
        D.21376 = (int) D.21242;
        num_refs = D.21376 & 255;
        e_start = start + 32;
        D.21346 = MEM[(struct MonoArray *)start].max_length;
        el_size.74 = (unsigned int) el_size;
        D.21348 = D.21346 * el_size.74;
        D.21349 = (sizetype) D.21348;
        e_end = e_start + D.21349;
        goto <D.19646>;
        <D.19645>:
        {
          void * * p;
          int i;

          p = e_start;
          D.21377 = (long unsigned int) offset;
          D.21378 = D.21377 * 8;
          p = p + D.21378;
          i = 0;
          goto <D.19643>;
          <D.19642>:
          {
            void * __old;
            void * __copy;

            D.21379 = (long unsigned int) i;
            D.21380 = D.21379 * 8;
            D.21381 = p + D.21380;
            __old = *D.21381;
            if (__old != 0B) goto <D.21382>; else goto <D.21383>;
            <D.21382>:
            __builtin_prefetch (__old);
            D.21379 = (long unsigned int) i;
            D.21380 = D.21379 * 8;
            D.21381 = p + D.21380;
            major_copy_or_mark_object (D.21381, __old, queue);
            D.21379 = (long unsigned int) i;
            D.21380 = D.21379 * 8;
            D.21381 = p + D.21380;
            __copy = *D.21381;
            if (0 != 0) goto <D.21384>; else goto <D.21385>;
            <D.21384>:
            if (__old != __copy) goto <D.21386>; else goto <D.21387>;
            <D.21386>:
            D.21379 = (long unsigned int) i;
            D.21380 = D.21379 * 8;
            D.21381 = p + D.21380;
            D.21388 = *D.21381;
            D.21379 = (long unsigned int) i;
            D.21380 = D.21379 * 8;
            D.21381 = p + D.21380;
            gc_debug_file.69 = gc_debug_file;
            fprintf (gc_debug_file.69, "Overwrote field at %p with %p (was: %p)\n", D.21381, D.21388, __old);
            gc_debug_file.69 = gc_debug_file;
            fflush (gc_debug_file.69);
            <D.21387>:
            <D.21385>:
            D.21392 = sgen_ptr_in_nursery (__copy);
            if (D.21392 != 0) goto <D.21393>; else goto <D.21390>;
            <D.21393>:
            D.21379 = (long unsigned int) i;
            D.21380 = D.21379 * 8;
            D.21394 = p + D.21380;
            D.21395 = sgen_ptr_in_nursery (D.21394);
            if (D.21395 == 0) goto <D.21396>; else goto <D.21390>;
            <D.21396>:
            iftmp.76 = 1;
            goto <D.21391>;
            <D.21390>:
            iftmp.76 = 0;
            <D.21391>:
            D.21397 = iftmp.76 != 0;
            D.21398 = (long int) D.21397;
            D.21399 = __builtin_expect (D.21398, 0);
            if (D.21399 != 0) goto <D.21400>; else goto <D.21401>;
            <D.21400>:
            D.21379 = (long unsigned int) i;
            D.21380 = D.21379 * 8;
            D.21402 = p + D.21380;
            sgen_add_to_global_remset (D.21402, __copy);
            <D.21401>:
            goto <D.21403>;
            <D.21383>:
            if (0 != 0) goto <D.21404>; else goto <D.21405>;
            <D.21404>:
            D.21379 = (long unsigned int) i;
            D.21380 = D.21379 * 8;
            D.21402 = p + D.21380;
            sgen_add_to_global_remset (D.21402, __old);
            <D.21405>:
            <D.21403>:
          }
          i = i + 1;
          <D.19643>:
          if (i < num_refs) goto <D.19642>; else goto <D.19644>;
          <D.19644>:
          D.21406 = (sizetype) el_size;
          e_start = e_start + D.21406;
        }
        <D.19646>:
        if (e_start < e_end) goto <D.19645>; else goto <D.19647>;
        <D.19647>:
      }
      goto <D.21407>;
      <D.21374>:
      if (etype == 49152) goto <D.21408>; else goto <D.21409>;
      <D.21408>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.21346 = MEM[(struct MonoArray *)start].max_length;
        el_size.74 = (unsigned int) el_size;
        D.21348 = D.21346 * el_size.74;
        D.21349 = (sizetype) D.21348;
        e_end = e_start + D.21349;
        goto <D.19658>;
        <D.19657>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.19655>;
          <D.19654>:
          D.21410 = _bmap & 1;
          if (D.21410 != 0) goto <D.21411>; else goto <D.21412>;
          <D.21411>:
          {
            void * __old;
            void * __copy;

            __old = *p;
            if (__old != 0B) goto <D.21413>; else goto <D.21414>;
            <D.21413>:
            __builtin_prefetch (__old);
            major_copy_or_mark_object (p, __old, queue);
            __copy = *p;
            if (0 != 0) goto <D.21415>; else goto <D.21416>;
            <D.21415>:
            if (__old != __copy) goto <D.21417>; else goto <D.21418>;
            <D.21417>:
            D.21419 = *p;
            gc_debug_file.69 = gc_debug_file;
            fprintf (gc_debug_file.69, "Overwrote field at %p with %p (was: %p)\n", p, D.21419, __old);
            gc_debug_file.69 = gc_debug_file;
            fflush (gc_debug_file.69);
            <D.21418>:
            <D.21416>:
            D.21423 = sgen_ptr_in_nursery (__copy);
            if (D.21423 != 0) goto <D.21424>; else goto <D.21421>;
            <D.21424>:
            D.21425 = sgen_ptr_in_nursery (p);
            if (D.21425 == 0) goto <D.21426>; else goto <D.21421>;
            <D.21426>:
            iftmp.77 = 1;
            goto <D.21422>;
            <D.21421>:
            iftmp.77 = 0;
            <D.21422>:
            D.21427 = iftmp.77 != 0;
            D.21428 = (long int) D.21427;
            D.21429 = __builtin_expect (D.21428, 0);
            if (D.21429 != 0) goto <D.21430>; else goto <D.21431>;
            <D.21430>:
            sgen_add_to_global_remset (p, __copy);
            <D.21431>:
            goto <D.21432>;
            <D.21414>:
            if (0 != 0) goto <D.21433>; else goto <D.21434>;
            <D.21433>:
            sgen_add_to_global_remset (p, __old);
            <D.21434>:
            <D.21432>:
          }
          <D.21412>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.19655>:
          if (_bmap != 0) goto <D.19654>; else goto <D.19656>;
          <D.19656>:
          D.21406 = (sizetype) el_size;
          e_start = e_start + D.21406;
        }
        <D.19658>:
        if (e_start < e_end) goto <D.19657>; else goto <D.19659>;
        <D.19659>:
      }
      <D.21409>:
      <D.21407>:
      <D.21372>:
    }
    <D.21340>:
    goto <D.19611>;
    <D.19660>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.19666>;
      <D.19665>:
      D.21435 = _bmap & 1;
      if (D.21435 != 0) goto <D.21436>; else goto <D.21437>;
      <D.21436>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21438>; else goto <D.21439>;
        <D.21438>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21440>; else goto <D.21441>;
        <D.21440>:
        if (__old != __copy) goto <D.21442>; else goto <D.21443>;
        <D.21442>:
        D.21444 = *_objptr;
        gc_debug_file.69 = gc_debug_file;
        fprintf (gc_debug_file.69, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21444, __old);
        gc_debug_file.69 = gc_debug_file;
        fflush (gc_debug_file.69);
        <D.21443>:
        <D.21441>:
        D.21448 = sgen_ptr_in_nursery (__copy);
        if (D.21448 != 0) goto <D.21449>; else goto <D.21446>;
        <D.21449>:
        D.21450 = sgen_ptr_in_nursery (_objptr);
        if (D.21450 == 0) goto <D.21451>; else goto <D.21446>;
        <D.21451>:
        iftmp.78 = 1;
        goto <D.21447>;
        <D.21446>:
        iftmp.78 = 0;
        <D.21447>:
        D.21452 = iftmp.78 != 0;
        D.21453 = (long int) D.21452;
        D.21454 = __builtin_expect (D.21453, 0);
        if (D.21454 != 0) goto <D.21455>; else goto <D.21456>;
        <D.21455>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21456>:
        goto <D.21457>;
        <D.21439>:
        if (0 != 0) goto <D.21458>; else goto <D.21459>;
        <D.21458>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.21459>:
        <D.21457>:
      }
      <D.21437>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.19666>:
      if (_bmap != 0) goto <D.19665>; else goto <D.19667>;
      <D.19667>:
    }
    goto <D.19611>;
    <D.19668>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.21460 = *bitmap_data;
      D.21461 = (unsigned int) D.21460;
      D.21462 = D.21461 + 4294967295;
      bwords = (int) D.21462;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.21463>; else goto <D.21464>;
      <D.21463>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.21465 = myobj->vtable;
        D.21466 = D.21465->klass;
        D.21467 = D.21466->name;
        D.21465 = myobj->vtable;
        D.21466 = D.21465->klass;
        D.21468 = D.21466->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21468, D.21467);
      }
      <D.21464>:
      goto <D.19681>;
      <D.19680>:
      {
        gsize _bmap;

        bitmap_data.79 = bitmap_data;
        bitmap_data = bitmap_data.79 + 8;
        _bmap = *bitmap_data.79;
        _objptr = start_run;
        goto <D.19678>;
        <D.19677>:
        D.21470 = _bmap & 1;
        if (D.21470 != 0) goto <D.21471>; else goto <D.21472>;
        <D.21471>:
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21473>; else goto <D.21474>;
          <D.21473>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21475>; else goto <D.21476>;
          <D.21475>:
          if (__old != __copy) goto <D.21477>; else goto <D.21478>;
          <D.21477>:
          D.21479 = *_objptr;
          gc_debug_file.69 = gc_debug_file;
          fprintf (gc_debug_file.69, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21479, __old);
          gc_debug_file.69 = gc_debug_file;
          fflush (gc_debug_file.69);
          <D.21478>:
          <D.21476>:
          D.21483 = sgen_ptr_in_nursery (__copy);
          if (D.21483 != 0) goto <D.21484>; else goto <D.21481>;
          <D.21484>:
          D.21485 = sgen_ptr_in_nursery (_objptr);
          if (D.21485 == 0) goto <D.21486>; else goto <D.21481>;
          <D.21486>:
          iftmp.80 = 1;
          goto <D.21482>;
          <D.21481>:
          iftmp.80 = 0;
          <D.21482>:
          D.21487 = iftmp.80 != 0;
          D.21488 = (long int) D.21487;
          D.21489 = __builtin_expect (D.21488, 0);
          if (D.21489 != 0) goto <D.21490>; else goto <D.21491>;
          <D.21490>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21491>:
          goto <D.21492>;
          <D.21474>:
          if (0 != 0) goto <D.21493>; else goto <D.21494>;
          <D.21493>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.21494>:
          <D.21492>:
        }
        <D.21472>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.19678>:
        if (_bmap != 0) goto <D.19677>; else goto <D.19679>;
        <D.19679>:
        start_run = start_run + 512;
      }
      <D.19681>:
      bwords.81 = bwords;
      bwords = bwords.81 + -1;
      if (bwords.81 > 0) goto <D.19680>; else goto <D.19682>;
      <D.19682>:
    }
    goto <D.19611>;
    <D.19683>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.21496 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.21496);
      mbitmap_data.82 = mbitmap_data;
      mbitmap_data = mbitmap_data.82 + 8;
      D.21498 = *mbitmap_data.82;
      D.21499 = (unsigned int) D.21498;
      D.21500 = D.21499 + 4294967295;
      mbwords = (int) D.21500;
      D.21501 = vt->klass;
      el_size = mono_array_element_size (D.21501);
      e_start = start + 32;
      D.21346 = MEM[(struct MonoArray *)start].max_length;
      el_size.83 = (unsigned int) el_size;
      D.21503 = D.21346 * el_size.83;
      D.21504 = (sizetype) D.21503;
      e_end = e_start + D.21504;
      if (0 != 0) goto <D.21505>; else goto <D.21506>;
      <D.21505>:
      D.21501 = vt->klass;
      D.21507 = D.21501->name;
      D.21501 = vt->klass;
      D.21508 = D.21501->name_space;
      D.21496 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.21496, D.21508, D.21507);
      <D.21506>:
      goto <D.19703>;
      <D.19702>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.19700>;
        <D.19699>:
        {
          gsize _bmap;
          void * * start_run;

          bitmap_data.84 = bitmap_data;
          bitmap_data = bitmap_data.84 + 8;
          _bmap = *bitmap_data.84;
          start_run = _objptr;
          goto <D.19697>;
          <D.19696>:
          D.21510 = _bmap & 1;
          if (D.21510 != 0) goto <D.21511>; else goto <D.21512>;
          <D.21511>:
          {
            void * __old;
            void * __copy;

            __old = *_objptr;
            if (__old != 0B) goto <D.21513>; else goto <D.21514>;
            <D.21513>:
            __builtin_prefetch (__old);
            major_copy_or_mark_object (_objptr, __old, queue);
            __copy = *_objptr;
            if (0 != 0) goto <D.21515>; else goto <D.21516>;
            <D.21515>:
            if (__old != __copy) goto <D.21517>; else goto <D.21518>;
            <D.21517>:
            D.21519 = *_objptr;
            gc_debug_file.69 = gc_debug_file;
            fprintf (gc_debug_file.69, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21519, __old);
            gc_debug_file.69 = gc_debug_file;
            fflush (gc_debug_file.69);
            <D.21518>:
            <D.21516>:
            D.21523 = sgen_ptr_in_nursery (__copy);
            if (D.21523 != 0) goto <D.21524>; else goto <D.21521>;
            <D.21524>:
            D.21525 = sgen_ptr_in_nursery (_objptr);
            if (D.21525 == 0) goto <D.21526>; else goto <D.21521>;
            <D.21526>:
            iftmp.85 = 1;
            goto <D.21522>;
            <D.21521>:
            iftmp.85 = 0;
            <D.21522>:
            D.21527 = iftmp.85 != 0;
            D.21528 = (long int) D.21527;
            D.21529 = __builtin_expect (D.21528, 0);
            if (D.21529 != 0) goto <D.21530>; else goto <D.21531>;
            <D.21530>:
            sgen_add_to_global_remset (_objptr, __copy);
            <D.21531>:
            goto <D.21532>;
            <D.21514>:
            if (0 != 0) goto <D.21533>; else goto <D.21534>;
            <D.21533>:
            sgen_add_to_global_remset (_objptr, __old);
            <D.21534>:
            <D.21532>:
          }
          <D.21512>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.19697>:
          if (_bmap != 0) goto <D.19696>; else goto <D.19698>;
          <D.19698>:
          _objptr = start_run + 512;
        }
        <D.19700>:
        bwords.86 = bwords;
        bwords = bwords.86 + 4294967295;
        if (bwords.86 != 0) goto <D.19699>; else goto <D.19701>;
        <D.19701>:
        D.21536 = (sizetype) el_size;
        e_start = e_start + D.21536;
      }
      <D.19703>:
      if (e_start < e_end) goto <D.19702>; else goto <D.19704>;
      <D.19704>:
    }
    goto <D.19611>;
    <D.19705>:
    goto <D.19611>;
    <D.19706>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.19611>:
  }
}


major_copy_or_mark_object (void * * ptr, void * obj, struct SgenGrayQueue * queue)
{
  int current_collection_generation.87;
  int D.21543;
  char * iftmp.88;
  long unsigned int D.21547;
  long unsigned int D.21548;
  long unsigned int D.21551;
  long unsigned int D.21555;
  int D.21558;
  _Bool D.21561;
  long int D.21562;
  long int D.21563;
  int D.21566;
  long unsigned int obj.89;
  long unsigned int D.21570;
  struct MSBlockHeader * D.21571;
  gboolean * evacuate_block_obj_sizes.90;
  long unsigned int D.21573;
  long unsigned int D.21574;
  gboolean * D.21575;
  long int obj.91;
  long int obj.92;
  long int D.21578;
  long int D.21579;
  long int D.21580;
  long unsigned int D.21586;
  long int D.21587;
  long unsigned int D.21588;
  long unsigned int D.21589;
  long unsigned int D.21592;
  unsigned char D.21593;
  unsigned char D.21594;
  int iftmp.93;
  struct GrayQueueSection * D.21601;
  int D.21603;
  _Bool D.21604;
  long int D.21605;
  long int D.21606;
  int D.21610;
  int D.21611;
  int D.21612;
  long unsigned int D.21620;
  long int D.21621;
  long unsigned int D.21622;
  long unsigned int D.21623;
  char * iftmp.94;
  unsigned int D.21631;
  unsigned int D.21632;
  long unsigned int D.21633;
  long unsigned int D.21636;
  long unsigned int D.21637;
  gboolean * D.21638;
  unsigned char D.21641;
  _Bool D.21643;
  long int D.21644;
  long int D.21645;
  unsigned char D.21648;
  long unsigned int D.21656;
  long int D.21657;
  long unsigned int D.21658;
  long unsigned int D.21659;
  long unsigned int D.21662;
  int iftmp.95;
  _Bool D.21670;
  long int D.21671;
  long int D.21672;
  int D.21676;
  int D.21677;
  int D.21679;
  struct MonoVTable * D.21682;
  void * D.21683;
  long unsigned int D.21684;
  int D.21685;
  int iftmp.96;
  _Bool D.21693;
  long int D.21694;
  long int D.21695;
  int D.21699;
  int D.21700;
  struct MSBlockInfo * block;
  void do_copy_object = <<< error >>>;

  if (0 != 0) goto <D.21538>; else goto <D.21539>;
  <D.21538>:
  monoeg_g_log (0B, 4, "null object from pointer %p", ptr);
  <D.19561>:
  goto <D.19561>;
  <D.21539>:
  if (0 != 0) goto <D.21540>; else goto <D.21541>;
  <D.21540>:
  current_collection_generation.87 = current_collection_generation;
  monoeg_g_log (0B, 4, "old gen parallel allocator called from a %d collection", current_collection_generation.87);
  <D.19562>:
  goto <D.19562>;
  <D.21541>:
  D.21543 = sgen_ptr_in_nursery (obj);
  if (D.21543 != 0) goto <D.21544>; else goto <D.21545>;
  <D.21544>:
  {
    int word;
    int bit;
    char * forwarded;
    char * old_obj;

    D.21547 = MEM[(mword *)obj];
    D.21548 = D.21547 & 1;
    if (D.21548 != 0) goto <D.21549>; else goto <D.21550>;
    <D.21549>:
    D.21547 = MEM[(mword *)obj];
    D.21551 = D.21547 & 18446744073709551612;
    iftmp.88 = (char *) D.21551;
    goto <D.21552>;
    <D.21550>:
    iftmp.88 = 0B;
    <D.21552>:
    forwarded = iftmp.88;
    if (forwarded != 0B) goto <D.21553>; else goto <D.21554>;
    <D.21553>:
    *ptr = forwarded;
    return;
    <D.21554>:
    D.21547 = MEM[(mword *)obj];
    D.21555 = D.21547 & 2;
    if (D.21555 != 0) goto <D.21556>; else goto <D.21557>;
    <D.21556>:
    return;
    <D.21557>:
    D.21558 = sgen_nursery_is_to_space (obj);
    if (D.21558 != 0) goto <D.21559>; else goto <D.21560>;
    <D.21559>:
    return;
    <D.21560>:
    do_copy_object:
    old_obj = obj;
    obj = copy_object_no_checks (obj, queue);
    D.21561 = old_obj == obj;
    D.21562 = (long int) D.21561;
    D.21563 = __builtin_expect (D.21562, 0);
    if (D.21563 != 0) goto <D.21564>; else goto <D.21565>;
    <D.21564>:
    D.21566 = sgen_ptr_in_nursery (obj);
    if (D.21566 == 0) goto <D.21567>; else goto <D.21568>;
    <D.21567>:
    {
      int size_index;

      obj.89 = (long unsigned int) obj;
      D.21570 = obj.89 & 18446744073709535232;
      D.21571 = (struct MSBlockHeader *) D.21570;
      block = D.21571->info;
      size_index = block->obj_size_index;
      evacuate_block_obj_sizes.90 = evacuate_block_obj_sizes;
      D.21573 = (long unsigned int) size_index;
      D.21574 = D.21573 * 4;
      D.21575 = evacuate_block_obj_sizes.90 + D.21574;
      *D.21575 = 0;
      {
        int __word;
        int __bit;

        {
          int i;

          obj.91 = (long int) obj;
          obj.92 = (long int) obj;
          D.21578 = obj.92 & -16384;
          D.21579 = obj.91 - D.21578;
          D.21580 = D.21579 >> 3;
          i = (int) D.21580;
          if (0 != 0) goto <D.21581>; else goto <D.21582>;
          <D.21581>:
          __word = i >> 5;
          __bit = i & 31;
          goto <D.21583>;
          <D.21582>:
          __word = i >> 6;
          __bit = i & 63;
          <D.21583>:
        }
        if (0 != 0) goto <D.21584>; else goto <D.21585>;
        <D.21584>:
        monoeg_g_log (0B, 4, "object %p not allocated", obj);
        <D.19572>:
        goto <D.19572>;
        <D.21585>:
        D.21586 = block->mark_words[__word];
        D.21587 = 1 << __bit;
        D.21588 = (long unsigned int) D.21587;
        D.21589 = D.21586 & D.21588;
        if (D.21589 == 0) goto <D.21590>; else goto <D.21591>;
        <D.21590>:
        D.21586 = block->mark_words[__word];
        D.21587 = 1 << __bit;
        D.21588 = (long unsigned int) D.21587;
        D.21592 = D.21586 | D.21588;
        block->mark_words[__word] = D.21592;
        D.21593 = BIT_FIELD_REF <*block, 8, 96>;
        D.21594 = D.21593 & 2;
        if (D.21594 != 0) goto <D.21595>; else goto <D.21596>;
        <D.21595>:
        D.21601 = queue->first;
        if (D.21601 == 0B) goto <D.21598>; else goto <D.21602>;
        <D.21602>:
        D.21601 = queue->first;
        D.21603 = D.21601->end;
        if (D.21603 == 125) goto <D.21598>; else goto <D.21599>;
        <D.21598>:
        iftmp.93 = 1;
        goto <D.21600>;
        <D.21599>:
        iftmp.93 = 0;
        <D.21600>:
        D.21604 = iftmp.93 != 0;
        D.21605 = (long int) D.21604;
        D.21606 = __builtin_expect (D.21605, 0);
        if (D.21606 != 0) goto <D.21607>; else goto <D.21608>;
        <D.21607>:
        sgen_gray_object_enqueue (queue, obj);
        goto <D.21609>;
        <D.21608>:
        D.21601 = queue->first;
        D.21601 = queue->first;
        D.21603 = D.21601->end;
        D.21610 = D.21603;
        D.21611 = D.21610 + 1;
        D.21601->end = D.21611;
        D.21601->objects[D.21610] = obj;
        <D.21609>:
        __builtin_prefetch (obj);
        <D.21596>:
        <D.21591>:
      }
    }
    <D.21568>:
    return;
    <D.21565>:
    *ptr = obj;
    D.21612 = sgen_ptr_in_nursery (obj);
    if (D.21612 == 0) goto <D.21613>; else goto <D.21614>;
    <D.21613>:
    obj.89 = (long unsigned int) obj;
    D.21570 = obj.89 & 18446744073709535232;
    D.21571 = (struct MSBlockHeader *) D.21570;
    block = D.21571->info;
    {
      int i;

      obj.91 = (long int) obj;
      obj.92 = (long int) obj;
      D.21578 = obj.92 & -16384;
      D.21579 = obj.91 - D.21578;
      D.21580 = D.21579 >> 3;
      i = (int) D.21580;
      if (0 != 0) goto <D.21615>; else goto <D.21616>;
      <D.21615>:
      word = i >> 5;
      bit = i & 31;
      goto <D.21617>;
      <D.21616>:
      word = i >> 6;
      bit = i & 63;
      <D.21617>:
    }
    if (0 != 0) goto <D.21618>; else goto <D.21619>;
    <D.21618>:
    monoeg_g_log (0B, 4, "object %p already marked", obj);
    <D.19574>:
    goto <D.19574>;
    <D.21619>:
    D.21620 = block->mark_words[word];
    D.21621 = 1 << bit;
    D.21622 = (long unsigned int) D.21621;
    D.21623 = D.21620 | D.21622;
    block->mark_words[word] = D.21623;
    <D.21614>:
  }
  goto <D.21624>;
  <D.21545>:
  {
    char * forwarded;
    mword objsize;

    D.21547 = MEM[(mword *)obj];
    D.21548 = D.21547 & 1;
    if (D.21548 != 0) goto <D.21626>; else goto <D.21627>;
    <D.21626>:
    D.21547 = MEM[(mword *)obj];
    D.21551 = D.21547 & 18446744073709551612;
    iftmp.94 = (char *) D.21551;
    goto <D.21628>;
    <D.21627>:
    iftmp.94 = 0B;
    <D.21628>:
    forwarded = iftmp.94;
    if (forwarded != 0B) goto <D.21629>; else goto <D.21630>;
    <D.21629>:
    *ptr = forwarded;
    return;
    <D.21630>:
    D.21631 = sgen_safe_object_get_size (obj);
    D.21632 = D.21631 + 7;
    D.21633 = (long unsigned int) D.21632;
    objsize = D.21633 & 4294967288;
    if (objsize <= 8000) goto <D.21634>; else goto <D.21635>;
    <D.21634>:
    {
      int size_index;
      gboolean evacuate;

      obj.89 = (long unsigned int) obj;
      D.21570 = obj.89 & 18446744073709535232;
      D.21571 = (struct MSBlockHeader *) D.21570;
      block = D.21571->info;
      size_index = block->obj_size_index;
      evacuate_block_obj_sizes.90 = evacuate_block_obj_sizes;
      D.21636 = (long unsigned int) size_index;
      D.21637 = D.21636 * 4;
      D.21638 = evacuate_block_obj_sizes.90 + D.21637;
      evacuate = *D.21638;
      if (evacuate != 0) goto <D.21640>; else goto <D.21639>;
      <D.21640>:
      D.21593 = BIT_FIELD_REF <*block, 8, 96>;
      D.21641 = D.21593 & 4;
      if (D.21641 == 0) goto <D.21642>; else goto <D.21639>;
      <D.21642>:
      D.21547 = MEM[(mword *)obj];
      D.21555 = D.21547 & 2;
      D.21643 = D.21555 != 0;
      D.21644 = (long int) D.21643;
      D.21645 = __builtin_expect (D.21644, 0);
      if (D.21645 != 0) goto <D.21646>; else goto <D.21647>;
      <D.21646>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 1425, "!SGEN_OBJECT_IS_PINNED (obj)");
      <D.21647>:
      D.21593 = BIT_FIELD_REF <*block, 8, 96>;
      D.21648 = D.21593 & 8;
      if (D.21648 != 0) goto <D.21649>; else goto <D.21650>;
      <D.21649>:
      return;
      <D.21650>:
      goto do_copy_object;
      <D.21639>:
      {
        int __word;
        int __bit;

        {
          int i;

          obj.91 = (long int) obj;
          obj.92 = (long int) obj;
          D.21578 = obj.92 & -16384;
          D.21579 = obj.91 - D.21578;
          D.21580 = D.21579 >> 3;
          i = (int) D.21580;
          if (0 != 0) goto <D.21651>; else goto <D.21652>;
          <D.21651>:
          __word = i >> 5;
          __bit = i & 31;
          goto <D.21653>;
          <D.21652>:
          __word = i >> 6;
          __bit = i & 63;
          <D.21653>:
        }
        if (0 != 0) goto <D.21654>; else goto <D.21655>;
        <D.21654>:
        monoeg_g_log (0B, 4, "object %p not allocated", obj);
        <D.19582>:
        goto <D.19582>;
        <D.21655>:
        D.21656 = block->mark_words[__word];
        D.21657 = 1 << __bit;
        D.21658 = (long unsigned int) D.21657;
        D.21659 = D.21656 & D.21658;
        if (D.21659 == 0) goto <D.21660>; else goto <D.21661>;
        <D.21660>:
        D.21656 = block->mark_words[__word];
        D.21657 = 1 << __bit;
        D.21658 = (long unsigned int) D.21657;
        D.21662 = D.21656 | D.21658;
        block->mark_words[__word] = D.21662;
        D.21593 = BIT_FIELD_REF <*block, 8, 96>;
        D.21594 = D.21593 & 2;
        if (D.21594 != 0) goto <D.21663>; else goto <D.21664>;
        <D.21663>:
        D.21601 = queue->first;
        if (D.21601 == 0B) goto <D.21666>; else goto <D.21669>;
        <D.21669>:
        D.21601 = queue->first;
        D.21603 = D.21601->end;
        if (D.21603 == 125) goto <D.21666>; else goto <D.21667>;
        <D.21666>:
        iftmp.95 = 1;
        goto <D.21668>;
        <D.21667>:
        iftmp.95 = 0;
        <D.21668>:
        D.21670 = iftmp.95 != 0;
        D.21671 = (long int) D.21670;
        D.21672 = __builtin_expect (D.21671, 0);
        if (D.21672 != 0) goto <D.21673>; else goto <D.21674>;
        <D.21673>:
        sgen_gray_object_enqueue (queue, obj);
        goto <D.21675>;
        <D.21674>:
        D.21601 = queue->first;
        D.21601 = queue->first;
        D.21603 = D.21601->end;
        D.21676 = D.21603;
        D.21677 = D.21676 + 1;
        D.21601->end = D.21677;
        D.21601->objects[D.21676] = obj;
        <D.21675>:
        __builtin_prefetch (obj);
        <D.21664>:
        <D.21661>:
      }
    }
    goto <D.21678>;
    <D.21635>:
    D.21679 = sgen_los_object_is_pinned (obj);
    if (D.21679 != 0) goto <D.21680>; else goto <D.21681>;
    <D.21680>:
    return;
    <D.21681>:
    sgen_los_pin_object (obj);
    D.21547 = MEM[(mword *)obj];
    D.21551 = D.21547 & 18446744073709551612;
    D.21682 = (struct MonoVTable *) D.21551;
    D.21683 = D.21682->gc_descr;
    D.21684 = (long unsigned int) D.21683;
    D.21685 = sgen_gc_descr_has_references (D.21684);
    if (D.21685 != 0) goto <D.21686>; else goto <D.21687>;
    <D.21686>:
    D.21601 = queue->first;
    if (D.21601 == 0B) goto <D.21689>; else goto <D.21692>;
    <D.21692>:
    D.21601 = queue->first;
    D.21603 = D.21601->end;
    if (D.21603 == 125) goto <D.21689>; else goto <D.21690>;
    <D.21689>:
    iftmp.96 = 1;
    goto <D.21691>;
    <D.21690>:
    iftmp.96 = 0;
    <D.21691>:
    D.21693 = iftmp.96 != 0;
    D.21694 = (long int) D.21693;
    D.21695 = __builtin_expect (D.21694, 0);
    if (D.21695 != 0) goto <D.21696>; else goto <D.21697>;
    <D.21696>:
    sgen_gray_object_enqueue (queue, obj);
    goto <D.21698>;
    <D.21697>:
    D.21601 = queue->first;
    D.21601 = queue->first;
    D.21603 = D.21601->end;
    D.21699 = D.21603;
    D.21700 = D.21699 + 1;
    D.21601->end = D.21700;
    D.21601->objects[D.21699] = obj;
    <D.21698>:
    __builtin_prefetch (obj);
    <D.21687>:
    <D.21678>:
  }
  <D.21624>:
}


sgen_nursery_is_to_space (char * object)
{
  long int object.97;
  char * sgen_nursery_start.98;
  long int sgen_nursery_start.99;
  long int D.21705;
  long int D.21706;
  int D.21707;
  _Bool D.21708;
  long int D.21709;
  long int D.21710;
  char * D.21713;
  char * D.21714;
  int sgen_space_bitmap_size.100;
  _Bool D.21716;
  long int D.21717;
  long int D.21718;
  gboolean D.21721;
  char * sgen_space_bitmap.101;
  sizetype D.21723;
  char * D.21724;
  char D.21725;
  int D.21726;
  int D.21727;
  int D.21728;
  _Bool D.21729;
  int idx;
  int byte;
  int bit;

  object.97 = (long int) object;
  sgen_nursery_start.98 = sgen_nursery_start;
  sgen_nursery_start.99 = (long int) sgen_nursery_start.98;
  D.21705 = object.97 - sgen_nursery_start.99;
  D.21706 = D.21705 >> 9;
  idx = (int) D.21706;
  byte = idx / 8;
  bit = idx & 7;
  D.21707 = sgen_ptr_in_nursery (object);
  D.21708 = D.21707 == 0;
  D.21709 = (long int) D.21708;
  D.21710 = __builtin_expect (D.21709, 0);
  if (D.21710 != 0) goto <D.21711>; else goto <D.21712>;
  <D.21711>:
  D.21713 = sgen_get_nursery_end ();
  D.21714 = sgen_get_nursery_start ();
  monoeg_g_log (0B, 4, "object %p is not in nursery [%p - %p]", object, D.21714, D.21713);
  <D.18615>:
  goto <D.18615>;
  <D.21712>:
  sgen_space_bitmap_size.100 = sgen_space_bitmap_size;
  D.21716 = byte >= sgen_space_bitmap_size.100;
  D.21717 = (long int) D.21716;
  D.21718 = __builtin_expect (D.21717, 0);
  if (D.21718 != 0) goto <D.21719>; else goto <D.21720>;
  <D.21719>:
  sgen_space_bitmap_size.100 = sgen_space_bitmap_size;
  monoeg_g_log (0B, 4, "byte index %d out of range", byte, sgen_space_bitmap_size.100);
  <D.18616>:
  goto <D.18616>;
  <D.21720>:
  sgen_space_bitmap.101 = sgen_space_bitmap;
  D.21723 = (sizetype) byte;
  D.21724 = sgen_space_bitmap.101 + D.21723;
  D.21725 = *D.21724;
  D.21726 = (int) D.21725;
  D.21727 = D.21726 >> bit;
  D.21728 = D.21727 & 1;
  D.21729 = D.21728 != 0;
  D.21721 = (gboolean) D.21729;
  return D.21721;
}


sgen_get_nursery_end ()
{
  char * D.21731;

  D.21731 = sgen_nursery_end;
  return D.21731;
}


sgen_get_nursery_start ()
{
  char * D.21733;

  D.21733 = sgen_nursery_start;
  return D.21733;
}


copy_object_no_checks (void * obj, struct SgenGrayQueue * queue)
{
  void * D.21735;
  long unsigned int D.21736;
  unsigned int D.21737;
  unsigned int D.21738;
  long unsigned int D.21739;
  char * (*<T306b>) (struct MonoVTable *, char *, size_t, gboolean) D.21740;
  _Bool D.21741;
  long int D.21742;
  long int D.21743;
  int D.21746;
  _Bool D.21750;
  long int D.21751;
  long int D.21752;
  void * D.21755;
  struct SgenGrayQueue * iftmp.102;
  long unsigned int destination.103;
  long unsigned int D.21761;
  struct MonoVTable * vt;
  gboolean has_references;
  mword objsize;
  char * destination;

  vt = MEM[(struct MonoObject *)obj].vtable;
  D.21735 = vt->gc_descr;
  D.21736 = (long unsigned int) D.21735;
  has_references = sgen_gc_descr_has_references (D.21736);
  D.21737 = sgen_par_object_get_size (vt, obj);
  D.21738 = D.21737 + 7;
  D.21739 = (long unsigned int) D.21738;
  objsize = D.21739 & 4294967288;
  D.21740 = sgen_minor_collector.alloc_for_promotion;
  destination = D.21740 (vt, obj, objsize, has_references);
  D.21741 = destination == 0B;
  D.21742 = (long int) D.21741;
  D.21743 = __builtin_expect (D.21742, 0);
  if (D.21743 != 0) goto <D.21744>; else goto <D.21745>;
  <D.21744>:
  D.21746 = sgen_ptr_in_nursery (obj);
  if (D.21746 != 0) goto <D.21747>; else goto <D.21748>;
  <D.21747>:
  sgen_pin_object (obj, queue);
  goto <D.21749>;
  <D.21748>:
  D.21750 = objsize > 8000;
  D.21751 = (long int) D.21750;
  D.21752 = __builtin_expect (D.21751, 0);
  if (D.21752 != 0) goto <D.21753>; else goto <D.21754>;
  <D.21753>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-copy-object.h", 115, "objsize <= SGEN_MAX_SMALL_OBJ_SIZE");
  <D.21754>:
  pin_major_object (obj, queue);
  <D.21749>:
  sgen_set_pinned_from_failed_allocation (objsize);
  D.21755 = obj;
  return D.21755;
  <D.21745>:
  if (has_references != 0) goto <D.21757>; else goto <D.21758>;
  <D.21757>:
  iftmp.102 = queue;
  goto <D.21759>;
  <D.21758>:
  iftmp.102 = 0B;
  <D.21759>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.102);
  destination.103 = (long unsigned int) destination;
  D.21761 = destination.103 | 1;
  MEM[(mword *)obj] = D.21761;
  D.21755 = destination;
  return D.21755;
}


par_copy_object_no_checks (char * destination, struct MonoVTable * vt, void * obj, mword objsize, struct SgenGrayQueue * queue)
{
  struct MonoClass * D.21765;
  const char * D.21766;
  const char * D.21767;
  struct MonoVTable * D.21770;
  struct MonoClass * D.21771;
  const char * D.21772;
  struct FILE * gc_debug_file.104;
  long unsigned int D.21776;
  const void * D.21777;
  mword * D.21778;
  long unsigned int D.21779;
  mword * D.21780;
  long unsigned int D.21781;
  mword * D.21782;
  long unsigned int D.21783;
  mword * D.21784;
  long unsigned int D.21785;
  mword * D.21786;
  long unsigned int D.21787;
  mword * D.21788;
  long unsigned int D.21789;
  mword * D.21790;
  long unsigned int D.21791;
  long unsigned int D.21793;
  const void * D.21794;
  void * D.21795;
  int iftmp.105;
  unsigned char D.21801;
  struct MonoArrayBounds * D.21803;
  _Bool D.21805;
  long int D.21806;
  long int D.21807;
  long int D.21810;
  long int obj.106;
  long int D.21812;
  sizetype D.21813;
  struct MonoArrayBounds * D.21814;
  long unsigned int D.21817;
  int D.21818;
  <unnamed type> mono_profiler_events.107;
  unsigned int D.21820;
  _Bool D.21821;
  long int D.21822;
  long int D.21823;
  const char * D.21830;
  int iftmp.108;
  struct GrayQueueSection * D.21835;
  int D.21837;
  _Bool D.21838;
  long int D.21839;
  long int D.21840;
  int D.21844;
  int D.21845;
  static const void * copy_labels[9] = {(const void *) &LAB_0, (const void *) &LAB_1, (const void *) &LAB_2, (const void *) &LAB_3, (const void *) &LAB_4, (const void *) &LAB_5, (const void *) &LAB_6, (const void *) &LAB_7, (const void *) &LAB_8};
  void LAB_0 = <<< error >>>;
  void LAB_1 = <<< error >>>;
  void LAB_2 = <<< error >>>;
  void LAB_3 = <<< error >>>;
  void LAB_4 = <<< error >>>;
  void LAB_5 = <<< error >>>;
  void LAB_6 = <<< error >>>;
  void LAB_7 = <<< error >>>;
  void LAB_8 = <<< error >>>;

  if (0 != 0) goto <D.21763>; else goto <D.21764>;
  <D.21763>:
  D.21765 = vt->klass;
  D.21766 = D.21765->name;
  D.21765 = vt->klass;
  D.21767 = D.21765->name_space;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s was not initialized", vt, D.21767, D.21766);
  <D.19532>:
  goto <D.19532>;
  <D.21764>:
  if (0 != 0) goto <D.21768>; else goto <D.21769>;
  <D.21768>:
  D.21770 = MEM[(struct MonoObject *)obj].vtable;
  D.21771 = D.21770->klass;
  D.21772 = D.21771->name;
  gc_debug_file.104 = gc_debug_file;
  fprintf (gc_debug_file.104, " (to %p, %s size: %lu)\n", destination, D.21772, objsize);
  gc_debug_file.104 = gc_debug_file;
  fflush (gc_debug_file.104);
  <D.21769>:
  if (objsize <= 64) goto <D.21774>; else goto <D.21775>;
  <D.21774>:
  {
    mword * dest;

    dest = destination;
    D.21776 = objsize / 8;
    D.21777 = copy_labels[D.21776];
    goto D.21777;
    LAB_8:
    D.21778 = dest + 56;
    D.21779 = MEM[(mword *)obj + 56B];
    *D.21778 = D.21779;
    LAB_7:
    D.21780 = dest + 48;
    D.21781 = MEM[(mword *)obj + 48B];
    *D.21780 = D.21781;
    LAB_6:
    D.21782 = dest + 40;
    D.21783 = MEM[(mword *)obj + 40B];
    *D.21782 = D.21783;
    LAB_5:
    D.21784 = dest + 32;
    D.21785 = MEM[(mword *)obj + 32B];
    *D.21784 = D.21785;
    LAB_4:
    D.21786 = dest + 24;
    D.21787 = MEM[(mword *)obj + 24B];
    *D.21786 = D.21787;
    LAB_3:
    D.21788 = dest + 16;
    D.21789 = MEM[(mword *)obj + 16B];
    *D.21788 = D.21789;
    LAB_2:
    D.21790 = dest + 8;
    D.21791 = MEM[(mword *)obj + 8B];
    *D.21790 = D.21791;
    LAB_1:
    LAB_0:
  }
  goto <D.21792>;
  <D.21775>:
  D.21793 = objsize + 18446744073709551608;
  D.21794 = obj + 8;
  D.21795 = destination + 8;
  mono_gc_memmove_aligned (D.21795, D.21794, D.21793);
  <D.21792>:
  if (0 != 0) goto <D.21796>; else goto <D.21797>;
  <D.21796>:
  D.21765 = vt->klass;
  D.21766 = D.21765->name;
  D.21765 = vt->klass;
  D.21767 = D.21765->name_space;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s has no gc descriptor", vt, D.21767, D.21766);
  <D.19534>:
  goto <D.19534>;
  <D.21797>:
  D.21801 = vt->rank;
  if (D.21801 != 0) goto <D.21802>; else goto <D.21799>;
  <D.21802>:
  D.21803 = MEM[(struct MonoArray *)obj].bounds;
  if (D.21803 != 0B) goto <D.21804>; else goto <D.21799>;
  <D.21804>:
  iftmp.105 = 1;
  goto <D.21800>;
  <D.21799>:
  iftmp.105 = 0;
  <D.21800>:
  D.21805 = iftmp.105 != 0;
  D.21806 = (long int) D.21805;
  D.21807 = __builtin_expect (D.21806, 0);
  if (D.21807 != 0) goto <D.21808>; else goto <D.21809>;
  <D.21808>:
  {
    struct MonoArray * array;

    array = destination;
    D.21803 = MEM[(struct MonoArray *)obj].bounds;
    D.21810 = (long int) D.21803;
    obj.106 = (long int) obj;
    D.21812 = D.21810 - obj.106;
    D.21813 = (sizetype) D.21812;
    D.21814 = destination + D.21813;
    array->bounds = D.21814;
    if (0 != 0) goto <D.21815>; else goto <D.21816>;
    <D.21815>:
    D.21817 = mono_array_length (array);
    D.21801 = vt->rank;
    D.21818 = (int) D.21801;
    gc_debug_file.104 = gc_debug_file;
    fprintf (gc_debug_file.104, "Array instance %p: size: %lu, rank: %d, length: %lu\n", array, objsize, D.21818, D.21817);
    gc_debug_file.104 = gc_debug_file;
    fflush (gc_debug_file.104);
    <D.21816>:
  }
  <D.21809>:
  mono_profiler_events.107 = mono_profiler_events;
  D.21820 = mono_profiler_events.107 & 524288;
  D.21821 = D.21820 != 0;
  D.21822 = (long int) D.21821;
  D.21823 = __builtin_expect (D.21822, 0);
  if (D.21823 != 0) goto <D.21824>; else goto <D.21825>;
  <D.21824>:
  sgen_register_moved_object (obj, destination);
  <D.21825>:
  obj = destination;
  if (queue != 0B) goto <D.21826>; else goto <D.21827>;
  <D.21826>:
  if (0 != 0) goto <D.21828>; else goto <D.21829>;
  <D.21828>:
  D.21830 = sgen_safe_name (obj);
  gc_debug_file.104 = gc_debug_file;
  fprintf (gc_debug_file.104, "Enqueuing gray object %p (%s)\n", obj, D.21830);
  gc_debug_file.104 = gc_debug_file;
  fflush (gc_debug_file.104);
  <D.21829>:
  D.21835 = queue->first;
  if (D.21835 == 0B) goto <D.21832>; else goto <D.21836>;
  <D.21836>:
  D.21835 = queue->first;
  D.21837 = D.21835->end;
  if (D.21837 == 125) goto <D.21832>; else goto <D.21833>;
  <D.21832>:
  iftmp.108 = 1;
  goto <D.21834>;
  <D.21833>:
  iftmp.108 = 0;
  <D.21834>:
  D.21838 = iftmp.108 != 0;
  D.21839 = (long int) D.21838;
  D.21840 = __builtin_expect (D.21839, 0);
  if (D.21840 != 0) goto <D.21841>; else goto <D.21842>;
  <D.21841>:
  sgen_gray_object_enqueue (queue, obj);
  goto <D.21843>;
  <D.21842>:
  D.21835 = queue->first;
  D.21835 = queue->first;
  D.21837 = D.21835->end;
  D.21844 = D.21837;
  D.21845 = D.21844 + 1;
  D.21835->end = D.21845;
  D.21835->objects[D.21844] = obj;
  <D.21843>:
  __builtin_prefetch (obj);
  <D.21827>:
}


major_copy_or_mark_object_canonical (void * * ptr, struct SgenGrayQueue * queue)
{
  void * D.21848;

  D.21848 = *ptr;
  major_copy_or_mark_object (ptr, D.21848, queue);
}


major_describe_pointer (char * ptr)
{
  char * D.21851;
  char * D.21853;
  int gc_debug_level.110;
  _Bool D.21855;
  long int D.21856;
  long int D.21857;
  <unnamed-unsigned:1> D.21860;
  int D.21861;
  <unnamed-unsigned:1> D.21862;
  int D.21863;
  int D.21864;
  struct FILE * gc_debug_file.111;
  long int ptr.112;
  char * D.21867;
  long int D.21868;
  long int D.21869;
  long int D.21870;
  long int D.21871;
  int D.21872;
  sizetype D.21873;
  sizetype D.21874;
  int iftmp.113;
  void * D.21879;
  char * D.21881;
  struct MonoVTable * iftmp.114;
  long unsigned int D.21886;
  long unsigned int D.21887;
  long int obj.115;
  long int obj.116;
  long int D.21891;
  long int D.21892;
  long int D.21893;
  long unsigned int D.21897;
  unsigned int D.21898;
  long int D.21899;
  unsigned int D.21900;
  unsigned int D.21901;
  long int D.21918;
  _Bool D.21924;
  int D.21925;
  struct MonoVTable * D.21926;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.19465>;
  <D.19464>:
  {
    int idx;
    char * obj;
    gboolean live;
    struct MonoVTable * vtable;
    int w;
    int b;
    gboolean marked;

    D.21851 = block->block;
    if (D.21851 > ptr) goto <D.21849>; else goto <D.21852>;
    <D.21852>:
    D.21851 = block->block;
    D.21853 = D.21851 + 16384;
    if (D.21853 <= ptr) goto <D.21849>; else goto <D.21850>;
    <D.21849>:
    // predicted unlikely by continue predictor.
    goto <D.19462>;
    <D.21850>:
    gc_debug_level.110 = gc_debug_level;
    D.21855 = gc_debug_level.110 >= 0;
    D.21856 = (long int) D.21855;
    D.21857 = __builtin_expect (D.21856, 0);
    if (D.21857 != 0) goto <D.21858>; else goto <D.21859>;
    <D.21858>:
    D.21860 = block->has_references;
    D.21861 = (int) D.21860;
    D.21862 = block->pinned;
    D.21863 = (int) D.21862;
    D.21864 = block->obj_size;
    D.21851 = block->block;
    gc_debug_file.111 = gc_debug_file;
    fprintf (gc_debug_file.111, "major-ptr (block %p sz %d pin %d ref %d)\n\n", D.21851, D.21864, D.21863, D.21861);
    gc_debug_file.111 = gc_debug_file;
    fflush (gc_debug_file.111);
    <D.21859>:
    ptr.112 = (long int) ptr;
    D.21851 = block->block;
    D.21867 = D.21851 + 16;
    D.21868 = (long int) D.21867;
    D.21869 = ptr.112 - D.21868;
    D.21864 = block->obj_size;
    D.21870 = (long int) D.21864;
    D.21871 = D.21869 / D.21870;
    idx = (int) D.21871;
    D.21851 = block->block;
    D.21864 = block->obj_size;
    D.21872 = D.21864 * idx;
    D.21873 = (sizetype) D.21872;
    D.21874 = D.21873 + 16;
    obj = D.21851 + D.21874;
    D.21879 = MEM[(void * *)obj];
    if (D.21879 != 0B) goto <D.21880>; else goto <D.21876>;
    <D.21880>:
    D.21881 = MEM[(char * *)obj];
    D.21851 = block->block;
    if (D.21881 < D.21851) goto <D.21877>; else goto <D.21882>;
    <D.21882>:
    D.21881 = MEM[(char * *)obj];
    D.21851 = block->block;
    D.21853 = D.21851 + 16384;
    if (D.21881 >= D.21853) goto <D.21877>; else goto <D.21876>;
    <D.21877>:
    iftmp.113 = 1;
    goto <D.21878>;
    <D.21876>:
    iftmp.113 = 0;
    <D.21878>:
    live = iftmp.113;
    if (live != 0) goto <D.21884>; else goto <D.21885>;
    <D.21884>:
    D.21886 = MEM[(mword *)obj];
    D.21887 = D.21886 & 18446744073709551612;
    iftmp.114 = (struct MonoVTable *) D.21887;
    goto <D.21888>;
    <D.21885>:
    iftmp.114 = 0B;
    <D.21888>:
    vtable = iftmp.114;
    {
      int i;

      obj.115 = (long int) obj;
      obj.116 = (long int) obj;
      D.21891 = obj.116 & -16384;
      D.21892 = obj.115 - D.21891;
      D.21893 = D.21892 >> 3;
      i = (int) D.21893;
      if (0 != 0) goto <D.21894>; else goto <D.21895>;
      <D.21894>:
      w = i >> 5;
      b = i & 31;
      goto <D.21896>;
      <D.21895>:
      w = i >> 6;
      b = i & 63;
      <D.21896>:
    }
    D.21897 = block->mark_words[w];
    D.21898 = (unsigned int) D.21897;
    D.21899 = 1 << b;
    D.21900 = (unsigned int) D.21899;
    D.21901 = D.21898 & D.21900;
    marked = (gboolean) D.21901;
    if (obj == ptr) goto <D.21902>; else goto <D.21903>;
    <D.21902>:
    gc_debug_level.110 = gc_debug_level;
    D.21855 = gc_debug_level.110 >= 0;
    D.21856 = (long int) D.21855;
    D.21857 = __builtin_expect (D.21856, 0);
    if (D.21857 != 0) goto <D.21904>; else goto <D.21905>;
    <D.21904>:
    gc_debug_file.111 = gc_debug_file;
    fprintf (gc_debug_file.111, "\t(\n");
    gc_debug_file.111 = gc_debug_file;
    fflush (gc_debug_file.111);
    <D.21905>:
    if (live != 0) goto <D.21906>; else goto <D.21907>;
    <D.21906>:
    gc_debug_level.110 = gc_debug_level;
    D.21855 = gc_debug_level.110 >= 0;
    D.21856 = (long int) D.21855;
    D.21857 = __builtin_expect (D.21856, 0);
    if (D.21857 != 0) goto <D.21908>; else goto <D.21909>;
    <D.21908>:
    gc_debug_file.111 = gc_debug_file;
    fprintf (gc_debug_file.111, "object\n");
    gc_debug_file.111 = gc_debug_file;
    fflush (gc_debug_file.111);
    <D.21909>:
    goto <D.21910>;
    <D.21907>:
    gc_debug_level.110 = gc_debug_level;
    D.21855 = gc_debug_level.110 >= 0;
    D.21856 = (long int) D.21855;
    D.21857 = __builtin_expect (D.21856, 0);
    if (D.21857 != 0) goto <D.21911>; else goto <D.21912>;
    <D.21911>:
    gc_debug_file.111 = gc_debug_file;
    fprintf (gc_debug_file.111, "dead-object\n");
    gc_debug_file.111 = gc_debug_file;
    fflush (gc_debug_file.111);
    <D.21912>:
    <D.21910>:
    goto <D.21913>;
    <D.21903>:
    if (live != 0) goto <D.21914>; else goto <D.21915>;
    <D.21914>:
    gc_debug_level.110 = gc_debug_level;
    D.21855 = gc_debug_level.110 >= 0;
    D.21856 = (long int) D.21855;
    D.21857 = __builtin_expect (D.21856, 0);
    if (D.21857 != 0) goto <D.21916>; else goto <D.21917>;
    <D.21916>:
    ptr.112 = (long int) ptr;
    obj.115 = (long int) obj;
    D.21918 = ptr.112 - obj.115;
    gc_debug_file.111 = gc_debug_file;
    fprintf (gc_debug_file.111, "interior-ptr offset %td\n", D.21918);
    gc_debug_file.111 = gc_debug_file;
    fflush (gc_debug_file.111);
    <D.21917>:
    goto <D.21919>;
    <D.21915>:
    gc_debug_level.110 = gc_debug_level;
    D.21855 = gc_debug_level.110 >= 0;
    D.21856 = (long int) D.21855;
    D.21857 = __builtin_expect (D.21856, 0);
    if (D.21857 != 0) goto <D.21920>; else goto <D.21921>;
    <D.21920>:
    ptr.112 = (long int) ptr;
    obj.115 = (long int) obj;
    D.21918 = ptr.112 - obj.115;
    gc_debug_file.111 = gc_debug_file;
    fprintf (gc_debug_file.111, "dead-interior-ptr offset %td\n", D.21918);
    gc_debug_file.111 = gc_debug_file;
    fflush (gc_debug_file.111);
    <D.21921>:
    <D.21919>:
    <D.21913>:
    gc_debug_level.110 = gc_debug_level;
    D.21855 = gc_debug_level.110 >= 0;
    D.21856 = (long int) D.21855;
    D.21857 = __builtin_expect (D.21856, 0);
    if (D.21857 != 0) goto <D.21922>; else goto <D.21923>;
    <D.21922>:
    D.21924 = marked != 0;
    D.21925 = (int) D.21924;
    gc_debug_file.111 = gc_debug_file;
    fprintf (gc_debug_file.111, " marked %d)\n\n", D.21925);
    gc_debug_file.111 = gc_debug_file;
    fflush (gc_debug_file.111);
    <D.21923>:
    D.21926 = vtable;
    return D.21926;
  }
  <D.19462>:
  block = block->next;
  <D.19465>:
  if (block != 0B) goto <D.19464>; else goto <D.19466>;
  <D.19466>:
  D.21926 = 0B;
  return D.21926;
}


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

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


major_is_valid_object (char * object)
{
  char * D.21932;
  char * D.21934;
  long int object.117;
  char * D.21936;
  long int D.21937;
  long int D.21938;
  int D.21939;
  long int D.21940;
  long int D.21941;
  int D.21942;
  sizetype D.21943;
  sizetype D.21944;
  gboolean D.21947;
  int iftmp.118;
  void * D.21952;
  char * D.21954;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.19449>;
  <D.19448>:
  {
    int idx;
    char * obj;

    D.21932 = block->block;
    if (D.21932 > object) goto <D.21930>; else goto <D.21933>;
    <D.21933>:
    D.21932 = block->block;
    D.21934 = D.21932 + 16384;
    if (D.21934 <= object) goto <D.21930>; else goto <D.21931>;
    <D.21930>:
    // predicted unlikely by continue predictor.
    goto <D.19447>;
    <D.21931>:
    object.117 = (long int) object;
    D.21932 = block->block;
    D.21936 = D.21932 + 16;
    D.21937 = (long int) D.21936;
    D.21938 = object.117 - D.21937;
    D.21939 = block->obj_size;
    D.21940 = (long int) D.21939;
    D.21941 = D.21938 / D.21940;
    idx = (int) D.21941;
    D.21932 = block->block;
    D.21939 = block->obj_size;
    D.21942 = D.21939 * idx;
    D.21943 = (sizetype) D.21942;
    D.21944 = D.21943 + 16;
    obj = D.21932 + D.21944;
    if (obj != object) goto <D.21945>; else goto <D.21946>;
    <D.21945>:
    D.21947 = 0;
    return D.21947;
    <D.21946>:
    D.21952 = MEM[(void * *)obj];
    if (D.21952 != 0B) goto <D.21953>; else goto <D.21949>;
    <D.21953>:
    D.21954 = MEM[(char * *)obj];
    D.21932 = block->block;
    if (D.21954 < D.21932) goto <D.21950>; else goto <D.21955>;
    <D.21955>:
    D.21954 = MEM[(char * *)obj];
    D.21932 = block->block;
    D.21934 = D.21932 + 16384;
    if (D.21954 >= D.21934) goto <D.21950>; else goto <D.21949>;
    <D.21950>:
    iftmp.118 = 1;
    goto <D.21951>;
    <D.21949>:
    iftmp.118 = 0;
    <D.21951>:
    D.21947 = iftmp.118;
    return D.21947;
  }
  <D.19447>:
  block = block->next;
  <D.19449>:
  if (block != 0B) goto <D.19448>; else goto <D.19450>;
  <D.19450>:
  D.21947 = 0;
  return D.21947;
}


post_param_init (struct SgenMajorCollector * collector)
{
  int lazy_sweep.119;

  lazy_sweep.119 = lazy_sweep;
  collector->sweeps_lazily = lazy_sweep.119;
}


major_print_gc_param_usage ()
{
  struct _IO_FILE * stderr.120;

  stderr.120 = stderr;
  fprintf (stderr.120, "  evacuation-threshold=P (where P is a percentage, an integer in 0-100)\n  (no-)lazy-sweep\n");
}


major_handle_gc_param (const char * opt)
{
  int D.21959;
  char * D.21962;
  unsigned int percentage.121;
  struct _IO_FILE * stderr.122;
  float D.21967;
  float evacuation_threshold.123;
  gboolean D.21969;
  int D.20110;
  int iftmp.124;
  int D.20109;
  const char[11] * D.21973;
  unsigned char D.21974;
  int D.21975;
  unsigned char D.21976;
  int D.21977;
  _Bool D.21978;
  _Bool D.21979;
  _Bool D.21980;
  const unsigned char * D.21983;
  unsigned char D.21984;
  int D.21985;
  const unsigned char * D.21986;
  unsigned char D.21987;
  int D.21988;
  _Bool D.21989;
  _Bool D.21990;
  const unsigned char * D.21993;
  unsigned char D.21994;
  int D.21995;
  const unsigned char * D.21996;
  unsigned char D.21997;
  int D.21998;
  _Bool D.21999;
  _Bool D.22000;
  const unsigned char * D.22003;
  unsigned char D.22004;
  int D.22005;
  const unsigned char * D.22006;
  unsigned char D.22007;
  int D.22008;
  int D.20119;
  int iftmp.125;
  int D.20118;
  const char[14] * D.22015;
  unsigned char D.22016;
  int D.22017;
  unsigned char D.22018;
  int D.22019;
  _Bool D.22020;
  _Bool D.22021;
  _Bool D.22022;
  const unsigned char * D.22025;
  unsigned char D.22026;
  int D.22027;
  const unsigned char * D.22028;
  unsigned char D.22029;
  int D.22030;
  _Bool D.22031;
  _Bool D.22032;
  const unsigned char * D.22035;
  unsigned char D.22036;
  int D.22037;
  const unsigned char * D.22038;
  unsigned char D.22039;
  int D.22040;
  _Bool D.22041;
  _Bool D.22042;
  const unsigned char * D.22045;
  unsigned char D.22046;
  int D.22047;
  const unsigned char * D.22048;
  unsigned char D.22049;
  int D.22050;

  D.21959 = monoeg_g_str_has_prefix (opt, "evacuation-threshold=");
  if (D.21959 != 0) goto <D.21960>; else goto <D.21961>;
  <D.21960>:
  {
    const char * arg;
    int percentage;

    D.21962 = __builtin_strchr (opt, 61);
    arg = D.21962 + 1;
    percentage = atoi (arg);
    percentage.121 = (unsigned int) percentage;
    if (percentage.121 > 100) goto <D.21964>; else goto <D.21965>;
    <D.21964>:
    stderr.122 = stderr;
    fprintf (stderr.122, "evacuation-threshold must be an integer in the range 0-100.\n");
    exit (1);
    <D.21965>:
    D.21967 = (float) percentage;
    evacuation_threshold.123 = D.21967 / 1.0e+2;
    evacuation_threshold = evacuation_threshold.123;
    D.21969 = 1;
    return D.21969;
  }
  <D.21961>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = opt;
      D.21973 = "lazy-sweep";
      D.21974 = MEM[(const unsigned char *)D.21973];
      D.21975 = (int) D.21974;
      D.21976 = *__s2;
      D.21977 = (int) D.21976;
      __result = D.21975 - D.21977;
      {
        D.21978 = __s2_len != 0;
        D.21979 = __result == 0;
        D.21980 = D.21978 & D.21979;
        if (D.21980 != 0) goto <D.21981>; else goto <D.21982>;
        <D.21981>:
        D.21983 = &MEM[(void *)"lazy-sweep" + 1B];
        D.21984 = *D.21983;
        D.21985 = (int) D.21984;
        D.21986 = __s2 + 1;
        D.21987 = *D.21986;
        D.21988 = (int) D.21987;
        __result = D.21985 - D.21988;
        D.21989 = __s2_len > 1;
        D.21979 = __result == 0;
        D.21990 = D.21989 & D.21979;
        if (D.21990 != 0) goto <D.21991>; else goto <D.21992>;
        <D.21991>:
        D.21993 = &MEM[(void *)"lazy-sweep" + 2B];
        D.21994 = *D.21993;
        D.21995 = (int) D.21994;
        D.21996 = __s2 + 2;
        D.21997 = *D.21996;
        D.21998 = (int) D.21997;
        __result = D.21995 - D.21998;
        D.21999 = __s2_len > 2;
        D.21979 = __result == 0;
        D.22000 = D.21999 & D.21979;
        if (D.22000 != 0) goto <D.22001>; else goto <D.22002>;
        <D.22001>:
        D.22003 = &MEM[(void *)"lazy-sweep" + 3B];
        D.22004 = *D.22003;
        D.22005 = (int) D.22004;
        D.22006 = __s2 + 3;
        D.22007 = *D.22006;
        D.22008 = (int) D.22007;
        __result = D.22005 - D.22008;
        <D.22002>:
        <D.21992>:
        <D.21982>:
      }
      D.20109 = __result;
    }
    iftmp.124 = -D.20109;
    goto <D.22009>;
    <D.21972>:
    iftmp.124 = __builtin_strcmp (opt, "lazy-sweep");
    <D.22009>:
    D.20110 = iftmp.124;
  }
  if (D.20110 == 0) goto <D.22010>; else goto <D.22011>;
  <D.22010>:
  lazy_sweep = 1;
  D.21969 = 1;
  return D.21969;
  <D.22011>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = opt;
      D.22015 = "no-lazy-sweep";
      D.22016 = MEM[(const unsigned char *)D.22015];
      D.22017 = (int) D.22016;
      D.22018 = *__s2;
      D.22019 = (int) D.22018;
      __result = D.22017 - D.22019;
      {
        D.22020 = __s2_len != 0;
        D.22021 = __result == 0;
        D.22022 = D.22020 & D.22021;
        if (D.22022 != 0) goto <D.22023>; else goto <D.22024>;
        <D.22023>:
        D.22025 = &MEM[(void *)"no-lazy-sweep" + 1B];
        D.22026 = *D.22025;
        D.22027 = (int) D.22026;
        D.22028 = __s2 + 1;
        D.22029 = *D.22028;
        D.22030 = (int) D.22029;
        __result = D.22027 - D.22030;
        D.22031 = __s2_len > 1;
        D.22021 = __result == 0;
        D.22032 = D.22031 & D.22021;
        if (D.22032 != 0) goto <D.22033>; else goto <D.22034>;
        <D.22033>:
        D.22035 = &MEM[(void *)"no-lazy-sweep" + 2B];
        D.22036 = *D.22035;
        D.22037 = (int) D.22036;
        D.22038 = __s2 + 2;
        D.22039 = *D.22038;
        D.22040 = (int) D.22039;
        __result = D.22037 - D.22040;
        D.22041 = __s2_len > 2;
        D.22021 = __result == 0;
        D.22042 = D.22041 & D.22021;
        if (D.22042 != 0) goto <D.22043>; else goto <D.22044>;
        <D.22043>:
        D.22045 = &MEM[(void *)"no-lazy-sweep" + 3B];
        D.22046 = *D.22045;
        D.22047 = (int) D.22046;
        D.22048 = __s2 + 3;
        D.22049 = *D.22048;
        D.22050 = (int) D.22049;
        __result = D.22047 - D.22050;
        <D.22044>:
        <D.22034>:
        <D.22024>:
      }
      D.20118 = __result;
    }
    iftmp.125 = -D.20118;
    goto <D.22051>;
    <D.22014>:
    iftmp.125 = __builtin_strcmp (opt, "no-lazy-sweep");
    <D.22051>:
    D.20119 = iftmp.125;
  }
  if (D.20119 == 0) goto <D.22052>; else goto <D.22053>;
  <D.22052>:
  lazy_sweep = 0;
  D.21969 = 1;
  return D.21969;
  <D.22053>:
  D.21969 = 0;
  return D.21969;
}


atoi (const char * __nptr)
{
  int D.22055;
  long int D.22056;

  D.22056 = strtol (__nptr, 0B, 10);
  D.22055 = (int) D.22056;
  return D.22055;
}


get_num_major_sections ()
{
  int D.22058;

  D.22058 = num_major_sections;
  return D.22058;
}


major_report_pinned_memory_usage ()
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-marksweep.c", 2077);
}


obj_is_from_pinned_alloc (char * ptr)
{
  char * D.22060;
  char * D.22063;
  gboolean D.22066;
  <unnamed-unsigned:1> D.22067;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.19343>;
  <D.19342>:
  D.22060 = block->block;
  if (D.22060 <= ptr) goto <D.22061>; else goto <D.22062>;
  <D.22061>:
  D.22060 = block->block;
  D.22063 = D.22060 + 16384;
  if (D.22063 >= ptr) goto <D.22064>; else goto <D.22065>;
  <D.22064>:
  D.22067 = block->pinned;
  D.22066 = (gboolean) D.22067;
  return D.22066;
  <D.22065>:
  <D.22062>:
  block = block->next;
  <D.19343>:
  if (block != 0B) goto <D.19342>; else goto <D.19344>;
  <D.19344>:
  D.22066 = 0;
  return D.22066;
}


major_ptr_is_in_non_pinned_space (char * ptr, char * * start)
{
  char * D.22069;
  char * D.22072;
  int D.22075;
  int D.22076;
  sizetype D.22077;
  sizetype D.22078;
  char * D.22079;
  int D.22082;
  int D.22083;
  sizetype D.22084;
  sizetype D.22085;
  char * D.22086;
  gboolean D.22089;
  unsigned char D.22090;
  unsigned char D.22091;
  _Bool D.22092;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.19422>;
  <D.19421>:
  D.22069 = block->block;
  if (D.22069 <= ptr) goto <D.22070>; else goto <D.22071>;
  <D.22070>:
  D.22069 = block->block;
  D.22072 = D.22069 + 16384;
  if (D.22072 >= ptr) goto <D.22073>; else goto <D.22074>;
  <D.22073>:
  {
    int count;
    int i;

    D.22075 = block->obj_size;
    count = 16368 / D.22075;
    *start = 0B;
    i = 0;
    goto <D.19420>;
    <D.19419>:
    D.22069 = block->block;
    D.22075 = block->obj_size;
    D.22076 = D.22075 * i;
    D.22077 = (sizetype) D.22076;
    D.22078 = D.22077 + 16;
    D.22079 = D.22069 + D.22078;
    if (D.22079 <= ptr) goto <D.22080>; else goto <D.22081>;
    <D.22080>:
    D.22069 = block->block;
    D.22075 = block->obj_size;
    D.22082 = i + 1;
    D.22083 = D.22075 * D.22082;
    D.22084 = (sizetype) D.22083;
    D.22085 = D.22084 + 16;
    D.22086 = D.22069 + D.22085;
    if (D.22086 > ptr) goto <D.22087>; else goto <D.22088>;
    <D.22087>:
    D.22069 = block->block;
    D.22075 = block->obj_size;
    D.22076 = D.22075 * i;
    D.22077 = (sizetype) D.22076;
    D.22078 = D.22077 + 16;
    D.22079 = D.22069 + D.22078;
    *start = D.22079;
    goto <D.19418>;
    <D.22088>:
    <D.22081>:
    i = i + 1;
    <D.19420>:
    if (i <= count) goto <D.19419>; else goto <D.19418>;
    <D.19418>:
    D.22090 = BIT_FIELD_REF <*block, 8, 96>;
    D.22091 = D.22090 & 1;
    D.22092 = D.22091 == 0;
    D.22089 = (gboolean) D.22092;
    return D.22089;
  }
  <D.22074>:
  <D.22071>:
  block = block->next;
  <D.19422>:
  if (block != 0B) goto <D.19421>; else goto <D.19423>;
  <D.19423>:
  D.22089 = 0;
  return D.22089;
}


major_have_computer_minor_collection_allowance ()
{
  long unsigned int D.22094;
  long unsigned int D.22095;
  int have_swept.126;
  _Bool D.22097;
  long int D.22098;
  long int D.22099;
  void * empty_blocks.127;
  int num_empty_blocks.128;
  int num_empty_blocks.129;
  long long int stat_major_blocks_freed.130;
  long long int stat_major_blocks_freed.131;
  int section_reserve;

  D.22094 = sgen_get_minor_collection_allowance ();
  D.22095 = D.22094 / 16384;
  section_reserve = (int) D.22095;
  have_swept.126 = have_swept;
  D.22097 = have_swept.126 == 0;
  D.22098 = (long int) D.22097;
  D.22099 = __builtin_expect (D.22098, 0);
  if (D.22099 != 0) goto <D.22100>; else goto <D.22101>;
  <D.22100>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 1898, "have_swept");
  <D.22101>:
  goto <D.20059>;
  <D.20058>:
  {
    void * next;

    empty_blocks.127 = empty_blocks;
    next = MEM[(void * *)empty_blocks.127];
    empty_blocks.127 = empty_blocks;
    sgen_free_os_memory (empty_blocks.127, 16384, 1);
    empty_blocks = next;
    num_empty_blocks.128 = num_empty_blocks;
    num_empty_blocks.129 = num_empty_blocks.128 + -1;
    num_empty_blocks = num_empty_blocks.129;
    stat_major_blocks_freed.130 = stat_major_blocks_freed;
    stat_major_blocks_freed.131 = stat_major_blocks_freed.130 + 1;
    stat_major_blocks_freed = stat_major_blocks_freed.131;
  }
  <D.20059>:
  num_empty_blocks.128 = num_empty_blocks;
  if (num_empty_blocks.128 > section_reserve) goto <D.20058>; else goto <D.20060>;
  <D.20060>:
}


major_finish_major_collection ()
{

}


major_start_major_collection ()
{
  gboolean * evacuate_block_obj_sizes.132;
  long unsigned int D.22108;
  long unsigned int D.22109;
  gboolean * D.22110;
  int D.22111;
  struct MSBlockInfo * * D.22114;
  long unsigned int D.22115;
  struct MSBlockInfo * * D.22116;
  struct MSBlockInfo * * D.22117;
  struct MSBlockInfo * * D.22118;
  int num_block_obj_sizes.133;
  int lazy_sweep.134;
  struct MSBlockInfo * D.22123;
  int i;

  i = 0;
  goto <D.20043>;
  <D.20042>:
  evacuate_block_obj_sizes.132 = evacuate_block_obj_sizes;
  D.22108 = (long unsigned int) i;
  D.22109 = D.22108 * 4;
  D.22110 = evacuate_block_obj_sizes.132 + D.22109;
  D.22111 = *D.22110;
  if (D.22111 == 0) goto <D.22112>; else goto <D.22113>;
  <D.22112>:
  // predicted unlikely by continue predictor.
  goto <D.20041>;
  <D.22113>:
  D.22114 = free_block_lists[0];
  D.22108 = (long unsigned int) i;
  D.22115 = D.22108 * 8;
  D.22116 = D.22114 + D.22115;
  *D.22116 = 0B;
  D.22117 = free_block_lists[2];
  D.22108 = (long unsigned int) i;
  D.22115 = D.22108 * 8;
  D.22118 = D.22117 + D.22115;
  *D.22118 = 0B;
  <D.20041>:
  i = i + 1;
  <D.20043>:
  num_block_obj_sizes.133 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.133) goto <D.20042>; else goto <D.20044>;
  <D.20044>:
  lazy_sweep.134 = lazy_sweep;
  if (lazy_sweep.134 != 0) goto <D.22121>; else goto <D.22122>;
  <D.22121>:
  {
    struct MSBlockInfo * * iter;

    iter = &all_blocks;
    goto <D.20048>;
    <D.20047>:
    {
      struct MSBlockInfo * block;

      block = *iter;
      sweep_block (block, 1);
      iter = &block->next;
    }
    <D.20048>:
    D.22123 = *iter;
    if (D.22123 != 0B) goto <D.20047>; else goto <D.20049>;
    <D.20049>:
  }
  <D.22122>:
}


sweep_block (struct MSBlockInfo * block, gboolean during_major_collection)
{
  int D.22126;
  _Bool D.22127;
  long int D.22128;
  long int D.22129;
  unsigned char D.22132;
  unsigned char D.22133;
  int D.22136;
  mword[32] * D.22137;
  void * * D.22138;
  int count;
  void * reversed;

  reversed = 0B;
  if (during_major_collection == 0) goto <D.22124>; else goto <D.22125>;
  <D.22124>:
  D.22126 = sgen_concurrent_collection_in_progress ();
  D.22127 = D.22126 != 0;
  D.22128 = (long int) D.22127;
  D.22129 = __builtin_expect (D.22128, 0);
  if (D.22129 != 0) goto <D.22130>; else goto <D.22131>;
  <D.22130>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 1551, "!sgen_concurrent_collection_in_progress ()");
  <D.22131>:
  <D.22125>:
  D.22132 = BIT_FIELD_REF <*block, 8, 96>;
  D.22133 = D.22132 & 16;
  if (D.22133 != 0) goto <D.22134>; else goto <D.22135>;
  <D.22134>:
  return;
  <D.22135>:
  D.22136 = block->obj_size;
  count = 16368 / D.22136;
  block->free_list = 0B;
  D.22136 = block->obj_size;
  switch (D.22136) <default: <D.19946>, case 16: <D.19944>>
  <D.19944>:
  sweep_block_for_size (block, count, 16);
  goto <D.19945>;
  <D.19946>:
  D.22136 = block->obj_size;
  sweep_block_for_size (block, count, D.22136);
  goto <D.19945>;
  <D.19945>:
  D.22137 = &block->mark_words;
  memset (D.22137, 0, 256);
  reversed = 0B;
  goto <D.19949>;
  <D.19948>:
  {
    void * next;

    D.22138 = block->free_list;
    next = *D.22138;
    D.22138 = block->free_list;
    *D.22138 = reversed;
    reversed = block->free_list;
    block->free_list = next;
  }
  <D.19949>:
  D.22138 = block->free_list;
  if (D.22138 != 0B) goto <D.19948>; else goto <D.19950>;
  <D.19950>:
  block->free_list = reversed;
  block->swept = 1;
}


sweep_block_for_size (struct MSBlockInfo * block, int count, int obj_size)
{
  char * D.22140;
  int D.22141;
  sizetype D.22142;
  sizetype D.22143;
  long int obj.135;
  long int obj.136;
  long int D.22146;
  long int D.22147;
  long int D.22148;
  long unsigned int D.22152;
  long int D.22153;
  long unsigned int D.22154;
  long unsigned int D.22155;
  void * D.22163;
  char * D.22166;
  char * D.22168;
  long unsigned int D.22169;
  void * * D.22170;
  int obj_index;

  obj_index = 0;
  goto <D.19936>;
  <D.19935>:
  {
    int word;
    int bit;
    void * obj;

    D.22140 = block->block;
    D.22141 = obj_size * obj_index;
    D.22142 = (sizetype) D.22141;
    D.22143 = D.22142 + 16;
    obj = D.22140 + D.22143;
    {
      int i;

      obj.135 = (long int) obj;
      obj.136 = (long int) obj;
      D.22146 = obj.136 & -16384;
      D.22147 = obj.135 - D.22146;
      D.22148 = D.22147 >> 3;
      i = (int) D.22148;
      if (0 != 0) goto <D.22149>; else goto <D.22150>;
      <D.22149>:
      word = i >> 5;
      bit = i & 31;
      goto <D.22151>;
      <D.22150>:
      word = i >> 6;
      bit = i & 63;
      <D.22151>:
    }
    D.22152 = block->mark_words[word];
    D.22153 = 1 << bit;
    D.22154 = (long unsigned int) D.22153;
    D.22155 = D.22152 & D.22154;
    if (D.22155 != 0) goto <D.22156>; else goto <D.22157>;
    <D.22156>:
    if (0 != 0) goto <D.22158>; else goto <D.22159>;
    <D.22158>:
    monoeg_g_log (0B, 4, "object %p not allocated", obj);
    <D.19934>:
    goto <D.19934>;
    <D.22159>:
    goto <D.22160>;
    <D.22157>:
    D.22163 = MEM[(void * *)obj];
    if (D.22163 != 0B) goto <D.22164>; else goto <D.22165>;
    <D.22164>:
    D.22166 = MEM[(char * *)obj];
    D.22140 = block->block;
    if (D.22166 < D.22140) goto <D.22161>; else goto <D.22167>;
    <D.22167>:
    D.22166 = MEM[(char * *)obj];
    D.22140 = block->block;
    D.22168 = D.22140 + 16384;
    if (D.22166 >= D.22168) goto <D.22161>; else goto <D.22162>;
    <D.22161>:
    D.22169 = (long unsigned int) obj_size;
    memset (obj, 0, D.22169);
    <D.22162>:
    <D.22165>:
    D.22170 = block->free_list;
    MEM[(void * *)obj] = D.22170;
    block->free_list = obj;
    <D.22160>:
  }
  obj_index = obj_index + 1;
  <D.19936>:
  if (obj_index < count) goto <D.19935>; else goto <D.19937>;
  <D.19937>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.22173;
  int D.22178;
  void * D.22180;
  long unsigned int D.22181;

  D.22173 = __builtin_constant_p (__len);
  if (D.22173 != 0) goto <D.22174>; else goto <D.22175>;
  <D.22174>:
  if (__len == 0) goto <D.22176>; else goto <D.22177>;
  <D.22176>:
  D.22178 = __builtin_constant_p (__ch);
  if (D.22178 == 0) goto <D.22171>; else goto <D.22179>;
  <D.22179>:
  if (__ch != 0) goto <D.22171>; else goto <D.22172>;
  <D.22171>:
  __warn_memset_zero_len ();
  D.22180 = __dest;
  return D.22180;
  <D.22172>:
  <D.22177>:
  <D.22175>:
  D.22181 = __builtin_object_size (__dest, 0);
  D.22180 = __builtin___memset_chk (__dest, __ch, __len, D.22181);
  return D.22180;
}


major_finish_nursery_collection ()
{
  int num_major_sections.137;
  int old_num_major_sections.138;
  int D.22185;

  num_major_sections.137 = num_major_sections;
  old_num_major_sections.138 = old_num_major_sections;
  D.22185 = num_major_sections.137 - old_num_major_sections.138;
  sgen_register_major_sections_alloced (D.22185);
}


major_start_nursery_collection ()
{
  int num_major_sections.139;

  num_major_sections.139 = num_major_sections;
  old_num_major_sections = num_major_sections.139;
}


major_get_used_size ()
{
  int D.22187;
  int D.22188;
  long int D.22189;
  long int D.22190;
  gint64 D.22191;
  gint64 size;
  struct MSBlockInfo * block;

  size = 0;
  block = all_blocks;
  goto <D.20092>;
  <D.20091>:
  {
    int count;
    void * * iter;

    D.22187 = block->obj_size;
    count = 16368 / D.22187;
    D.22187 = block->obj_size;
    D.22188 = D.22187 * count;
    D.22189 = (long int) D.22188;
    size = D.22189 + size;
    iter = block->free_list;
    goto <D.20089>;
    <D.20088>:
    D.22187 = block->obj_size;
    D.22190 = (long int) D.22187;
    size = size - D.22190;
    iter = *iter;
    <D.20089>:
    if (iter != 0B) goto <D.20088>; else goto <D.20090>;
    <D.20090>:
  }
  block = block->next;
  <D.20092>:
  if (block != 0B) goto <D.20091>; else goto <D.20093>;
  <D.20093>:
  D.22191 = size;
  return D.22191;
}


major_dump_heap (struct FILE * heap_dump_file)
{
  int num_block_obj_sizes.140;
  long unsigned int D.22194;
  long unsigned int D.22195;
  long unsigned int D.22196;
  long unsigned int D.22197;
  int * D.22198;
  int * D.22199;
  int D.22200;
  int D.22201;
  long unsigned int D.22202;
  long unsigned int D.22203;
  int * D.22204;
  int D.22205;
  int D.22206;
  char * D.22209;
  int D.22210;
  sizetype D.22211;
  sizetype D.22212;
  char * D.22213;
  void * D.22214;
  char * D.22217;
  char * D.22219;
  int * D.22220;
  int D.22221;
  int D.22222;
  int D.22223;
  int * block_obj_sizes.141;
  int * D.22225;
  int D.22226;
  int D.22231;
  sizetype D.22232;
  sizetype D.22233;
  char * D.22234;
  void * D.22235;
  char * D.22237;
  int D.22243;
  sizetype D.22244;
  sizetype D.22245;
  char * D.22246;
  struct MSBlockInfo * block;
  int * slots_available;
  int * slots_used;
  int i;

  num_block_obj_sizes.140 = num_block_obj_sizes;
  D.22194 = (long unsigned int) num_block_obj_sizes.140;
  D.22195 = D.22194 * 4;
  slots_available = __builtin_alloca (D.22195);
  num_block_obj_sizes.140 = num_block_obj_sizes;
  D.22194 = (long unsigned int) num_block_obj_sizes.140;
  D.22195 = D.22194 * 4;
  slots_used = __builtin_alloca (D.22195);
  i = 0;
  goto <D.19478>;
  <D.19477>:
  D.22196 = (long unsigned int) i;
  D.22197 = D.22196 * 4;
  D.22198 = slots_available + D.22197;
  D.22196 = (long unsigned int) i;
  D.22197 = D.22196 * 4;
  D.22199 = slots_used + D.22197;
  *D.22199 = 0;
  D.22200 = *D.22199;
  *D.22198 = D.22200;
  i = i + 1;
  <D.19478>:
  num_block_obj_sizes.140 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.140) goto <D.19477>; else goto <D.19479>;
  <D.19479>:
  block = all_blocks;
  goto <D.19486>;
  <D.19485>:
  {
    int index;
    int count;

    D.22201 = block->obj_size;
    index = ms_find_block_obj_size_index (D.22201);
    D.22201 = block->obj_size;
    count = 16368 / D.22201;
    D.22202 = (long unsigned int) index;
    D.22203 = D.22202 * 4;
    D.22204 = slots_available + D.22203;
    D.22202 = (long unsigned int) index;
    D.22203 = D.22202 * 4;
    D.22204 = slots_available + D.22203;
    D.22205 = *D.22204;
    D.22206 = D.22205 + count;
    *D.22204 = D.22206;
    i = 0;
    goto <D.19483>;
    <D.19482>:
    D.22209 = block->block;
    D.22201 = block->obj_size;
    D.22210 = D.22201 * i;
    D.22211 = (sizetype) D.22210;
    D.22212 = D.22211 + 16;
    D.22213 = D.22209 + D.22212;
    D.22214 = MEM[(void * *)D.22213];
    if (D.22214 != 0B) goto <D.22215>; else goto <D.22216>;
    <D.22215>:
    D.22209 = block->block;
    D.22201 = block->obj_size;
    D.22210 = D.22201 * i;
    D.22211 = (sizetype) D.22210;
    D.22212 = D.22211 + 16;
    D.22213 = D.22209 + D.22212;
    D.22217 = MEM[(char * *)D.22213];
    D.22209 = block->block;
    if (D.22217 < D.22209) goto <D.22207>; else goto <D.22218>;
    <D.22218>:
    D.22209 = block->block;
    D.22201 = block->obj_size;
    D.22210 = D.22201 * i;
    D.22211 = (sizetype) D.22210;
    D.22212 = D.22211 + 16;
    D.22213 = D.22209 + D.22212;
    D.22217 = MEM[(char * *)D.22213];
    D.22209 = block->block;
    D.22219 = D.22209 + 16384;
    if (D.22217 >= D.22219) goto <D.22207>; else goto <D.22208>;
    <D.22207>:
    D.22202 = (long unsigned int) index;
    D.22203 = D.22202 * 4;
    D.22220 = slots_used + D.22203;
    D.22221 = *D.22220;
    D.22222 = D.22221 + 1;
    *D.22220 = D.22222;
    <D.22208>:
    <D.22216>:
    i = i + 1;
    <D.19483>:
    if (i < count) goto <D.19482>; else goto <D.19484>;
    <D.19484>:
  }
  block = block->next;
  <D.19486>:
  if (block != 0B) goto <D.19485>; else goto <D.19487>;
  <D.19487>:
  fprintf (heap_dump_file, "<occupancies>\n");
  i = 0;
  goto <D.19489>;
  <D.19488>:
  D.22196 = (long unsigned int) i;
  D.22197 = D.22196 * 4;
  D.22199 = slots_used + D.22197;
  D.22200 = *D.22199;
  D.22196 = (long unsigned int) i;
  D.22197 = D.22196 * 4;
  D.22198 = slots_available + D.22197;
  D.22223 = *D.22198;
  block_obj_sizes.141 = block_obj_sizes;
  D.22196 = (long unsigned int) i;
  D.22197 = D.22196 * 4;
  D.22225 = block_obj_sizes.141 + D.22197;
  D.22226 = *D.22225;
  fprintf (heap_dump_file, "<occupancy size=\"%d\" available=\"%d\" used=\"%d\" />\n", D.22226, D.22223, D.22200);
  i = i + 1;
  <D.19489>:
  num_block_obj_sizes.140 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.140) goto <D.19488>; else goto <D.19490>;
  <D.19490>:
  fprintf (heap_dump_file, "</occupancies>\n");
  block = all_blocks;
  goto <D.19498>;
  <D.19497>:
  {
    int count;
    int i;
    int start;

    D.22201 = block->obj_size;
    count = 16368 / D.22201;
    start = -1;
    fprintf (heap_dump_file, "<section type=\"%s\" size=\"%zu\">\n", "old", 16368);
    i = 0;
    goto <D.19495>;
    <D.19494>:
    if (i < count) goto <D.22230>; else goto <D.22227>;
    <D.22230>:
    D.22209 = block->block;
    D.22201 = block->obj_size;
    D.22231 = D.22201 * i;
    D.22232 = (sizetype) D.22231;
    D.22233 = D.22232 + 16;
    D.22234 = D.22209 + D.22233;
    D.22235 = MEM[(void * *)D.22234];
    if (D.22235 != 0B) goto <D.22236>; else goto <D.22227>;
    <D.22236>:
    D.22209 = block->block;
    D.22201 = block->obj_size;
    D.22231 = D.22201 * i;
    D.22232 = (sizetype) D.22231;
    D.22233 = D.22232 + 16;
    D.22234 = D.22209 + D.22233;
    D.22237 = MEM[(char * *)D.22234];
    D.22209 = block->block;
    if (D.22237 < D.22209) goto <D.22228>; else goto <D.22238>;
    <D.22238>:
    D.22209 = block->block;
    D.22201 = block->obj_size;
    D.22231 = D.22201 * i;
    D.22232 = (sizetype) D.22231;
    D.22233 = D.22232 + 16;
    D.22234 = D.22209 + D.22233;
    D.22237 = MEM[(char * *)D.22234];
    D.22209 = block->block;
    D.22219 = D.22209 + 16384;
    if (D.22237 >= D.22219) goto <D.22228>; else goto <D.22227>;
    <D.22228>:
    if (start < 0) goto <D.22239>; else goto <D.22240>;
    <D.22239>:
    start = i;
    <D.22240>:
    goto <D.22229>;
    <D.22227>:
    if (start >= 0) goto <D.22241>; else goto <D.22242>;
    <D.22241>:
    D.22209 = block->block;
    D.22209 = block->block;
    D.22201 = block->obj_size;
    D.22231 = D.22201 * i;
    D.22232 = (sizetype) D.22231;
    D.22233 = D.22232 + 16;
    D.22234 = D.22209 + D.22233;
    D.22209 = block->block;
    D.22201 = block->obj_size;
    D.22243 = D.22201 * start;
    D.22244 = (sizetype) D.22243;
    D.22245 = D.22244 + 16;
    D.22246 = D.22209 + D.22245;
    sgen_dump_occupied (D.22246, D.22234, D.22209);
    start = -1;
    <D.22242>:
    <D.22229>:
    i = i + 1;
    <D.19495>:
    if (i <= count) goto <D.19494>; else goto <D.19496>;
    <D.19496>:
    fprintf (heap_dump_file, "</section>\n");
  }
  block = block->next;
  <D.19498>:
  if (block != 0B) goto <D.19497>; else goto <D.19499>;
  <D.19499>:
}


major_check_scan_starts ()
{

}


major_sweep ()
{
  ms_sweep ();
}


ms_sweep ()
{
  int num_block_obj_sizes.142;
  long unsigned int D.22248;
  long unsigned int D.22249;
  long unsigned int D.22250;
  long unsigned int D.22251;
  int * D.22252;
  int * D.22253;
  int * D.22254;
  int D.22255;
  int D.22256;
  long unsigned int D.22257;
  long unsigned int D.22258;
  struct MSBlockInfo * * D.22259;
  <unnamed-unsigned:1> D.22260;
  <unnamed-unsigned:1> D.22261;
  int D.22262;
  guint8 * D.22263;
  long unsigned int D.22266;
  int D.22267;
  unsigned int i.143;
  int lazy_sweep.144;
  long unsigned int D.22280;
  long unsigned int D.22281;
  int * D.22282;
  int D.22283;
  int D.22284;
  int * D.22285;
  int D.22286;
  int D.22287;
  int * D.22288;
  int D.22289;
  int D.22290;
  unsigned char D.22293;
  unsigned char D.22294;
  _Bool D.22295;
  int D.22296;
  int D.22297;
  int D.22298;
  int D.22299;
  int iftmp.145;
  int D.22301;
  int D.22302;
  long unsigned int D.22306;
  long unsigned int D.22307;
  struct MSBlockInfo * * D.22308;
  struct MSBlockInfo * D.22309;
  struct MSBlockInfo * D.22311;
  char * D.22312;
  int num_major_sections.146;
  int num_major_sections.147;
  struct MSBlockInfo * D.22315;
  float D.22316;
  int D.22317;
  float D.22318;
  float evacuation_threshold.148;
  gboolean * evacuate_block_obj_sizes.149;
  gboolean * D.22325;
  int * block_obj_sizes.150;
  int * D.22327;
  int D.22328;
  int D.22329;
  int D.22330;
  int D.22333;
  long unsigned int D.22334;
  long unsigned int D.22335;
  float D.22336;
  float D.22337;
  float D.22338;
  float concurrent_evacuation_threshold.151;
  float D.22340;
  _Bool D.22341;
  int want_evacuation.152;
  int i;
  struct MSBlockInfo * * iter;
  int * slots_available;
  int * slots_used;
  int * num_blocks;
  mword total_evacuate_heap;
  mword total_evacuate_saved;

  num_block_obj_sizes.142 = num_block_obj_sizes;
  D.22248 = (long unsigned int) num_block_obj_sizes.142;
  D.22249 = D.22248 * 4;
  slots_available = __builtin_alloca (D.22249);
  num_block_obj_sizes.142 = num_block_obj_sizes;
  D.22248 = (long unsigned int) num_block_obj_sizes.142;
  D.22249 = D.22248 * 4;
  slots_used = __builtin_alloca (D.22249);
  num_block_obj_sizes.142 = num_block_obj_sizes;
  D.22248 = (long unsigned int) num_block_obj_sizes.142;
  D.22249 = D.22248 * 4;
  num_blocks = __builtin_alloca (D.22249);
  total_evacuate_heap = 0;
  total_evacuate_saved = 0;
  i = 0;
  goto <D.19966>;
  <D.19965>:
  D.22250 = (long unsigned int) i;
  D.22251 = D.22250 * 4;
  D.22252 = slots_available + D.22251;
  D.22250 = (long unsigned int) i;
  D.22251 = D.22250 * 4;
  D.22253 = slots_used + D.22251;
  D.22250 = (long unsigned int) i;
  D.22251 = D.22250 * 4;
  D.22254 = num_blocks + D.22251;
  *D.22254 = 0;
  D.22255 = *D.22254;
  *D.22253 = D.22255;
  D.22256 = *D.22253;
  *D.22252 = D.22256;
  i = i + 1;
  <D.19966>:
  num_block_obj_sizes.142 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.142) goto <D.19965>; else goto <D.19967>;
  <D.19967>:
  i = 0;
  goto <D.19974>;
  <D.19973>:
  {
    struct MSBlockInfo * * free_blocks;
    int j;

    free_blocks = free_block_lists[i];
    j = 0;
    goto <D.19971>;
    <D.19970>:
    D.22257 = (long unsigned int) j;
    D.22258 = D.22257 * 8;
    D.22259 = free_blocks + D.22258;
    *D.22259 = 0B;
    j = j + 1;
    <D.19971>:
    num_block_obj_sizes.142 = num_block_obj_sizes;
    if (j < num_block_obj_sizes.142) goto <D.19970>; else goto <D.19972>;
    <D.19972>:
  }
  i = i + 1;
  <D.19974>:
  if (i <= 3) goto <D.19973>; else goto <D.19975>;
  <D.19975>:
  iter = &all_blocks;
  goto <D.19989>;
  <D.19988>:
  {
    struct MSBlockInfo * block;
    int count;
    gboolean have_live;
    gboolean has_pinned;
    gboolean have_free;
    int obj_size_index;
    int nused;

    block = *iter;
    have_live = 0;
    have_free = 0;
    nused = 0;
    obj_size_index = block->obj_size_index;
    D.22260 = block->has_pinned;
    has_pinned = (gboolean) D.22260;
    D.22261 = block->pinned;
    block->has_pinned = D.22261;
    block->is_to_space = 0;
    block->swept = 0;
    D.22262 = block->obj_size;
    count = 16368 / D.22262;
    D.22263 = block->cardtable_mod_union;
    if (D.22263 != 0B) goto <D.22264>; else goto <D.22265>;
    <D.22264>:
    D.22263 = block->cardtable_mod_union;
    sgen_free_internal_dynamic (D.22263, 32, 28);
    block->cardtable_mod_union = 0B;
    <D.22265>:
    i = 0;
    goto <D.19984>;
    <D.19983>:
    D.22266 = block->mark_words[i];
    D.22267 = bitcount (D.22266);
    nused = D.22267 + nused;
    i = i + 1;
    <D.19984>:
    i.143 = (unsigned int) i;
    if (i.143 <= 31) goto <D.19983>; else goto <D.19985>;
    <D.19985>:
    if (nused != 0) goto <D.22269>; else goto <D.22270>;
    <D.22269>:
    have_live = 1;
    <D.22270>:
    if (nused < count) goto <D.22271>; else goto <D.22272>;
    <D.22271>:
    have_free = 1;
    <D.22272>:
    lazy_sweep.144 = lazy_sweep;
    if (lazy_sweep.144 == 0) goto <D.22274>; else goto <D.22275>;
    <D.22274>:
    sweep_block (block, 1);
    <D.22275>:
    if (have_live != 0) goto <D.22276>; else goto <D.22277>;
    <D.22276>:
    if (has_pinned == 0) goto <D.22278>; else goto <D.22279>;
    <D.22278>:
    D.22280 = (long unsigned int) obj_size_index;
    D.22281 = D.22280 * 4;
    D.22282 = num_blocks + D.22281;
    D.22283 = *D.22282;
    D.22284 = D.22283 + 1;
    *D.22282 = D.22284;
    D.22280 = (long unsigned int) obj_size_index;
    D.22281 = D.22280 * 4;
    D.22285 = slots_used + D.22281;
    D.22280 = (long unsigned int) obj_size_index;
    D.22281 = D.22280 * 4;
    D.22285 = slots_used + D.22281;
    D.22286 = *D.22285;
    D.22287 = D.22286 + nused;
    *D.22285 = D.22287;
    D.22280 = (long unsigned int) obj_size_index;
    D.22281 = D.22280 * 4;
    D.22288 = slots_available + D.22281;
    D.22280 = (long unsigned int) obj_size_index;
    D.22281 = D.22280 * 4;
    D.22288 = slots_available + D.22281;
    D.22289 = *D.22288;
    D.22290 = D.22289 + count;
    *D.22288 = D.22290;
    <D.22279>:
    iter = &block->next;
    if (have_free != 0) goto <D.22291>; else goto <D.22292>;
    <D.22291>:
    {
      struct MSBlockInfo * * free_blocks;
      int index;

      D.22293 = BIT_FIELD_REF <*block, 8, 96>;
      D.22294 = D.22293 & 1;
      D.22295 = D.22294 != 0;
      D.22296 = (int) D.22295;
      D.22293 = BIT_FIELD_REF <*block, 8, 96>;
      D.22297 = (int) D.22293;
      D.22298 = D.22297 & 2;
      D.22299 = D.22296 | D.22298;
      free_blocks = free_block_lists[D.22299];
      D.22262 = block->obj_size;
      D.22301 = D.22262 + 7;
      D.22302 = D.22301 >> 3;
      if (D.22302 <= 31) goto <D.22303>; else goto <D.22304>;
      <D.22303>:
      D.22262 = block->obj_size;
      D.22301 = D.22262 + 7;
      D.22302 = D.22301 >> 3;
      iftmp.145 = fast_block_obj_size_indexes[D.22302];
      goto <D.22305>;
      <D.22304>:
      D.22262 = block->obj_size;
      iftmp.145 = ms_find_block_obj_size_index (D.22262);
      <D.22305>:
      index = iftmp.145;
      D.22306 = (long unsigned int) index;
      D.22307 = D.22306 * 8;
      D.22308 = free_blocks + D.22307;
      D.22309 = *D.22308;
      block->next_free = D.22309;
      D.22306 = (long unsigned int) index;
      D.22307 = D.22306 * 8;
      D.22308 = free_blocks + D.22307;
      *D.22308 = block;
    }
    <D.22292>:
    update_heap_boundaries_for_block (block);
    goto <D.22310>;
    <D.22277>:
    D.22311 = block->next;
    *iter = D.22311;
    D.22312 = block->block;
    ms_free_block (D.22312);
    sgen_free_internal (block, 16);
    num_major_sections.146 = num_major_sections;
    num_major_sections.147 = num_major_sections.146 + -1;
    num_major_sections = num_major_sections.147;
    <D.22310>:
  }
  <D.19989>:
  D.22315 = *iter;
  if (D.22315 != 0B) goto <D.19988>; else goto <D.19990>;
  <D.19990>:
  i = 0;
  goto <D.19994>;
  <D.19993>:
  {
    float usage;

    D.22250 = (long unsigned int) i;
    D.22251 = D.22250 * 4;
    D.22253 = slots_used + D.22251;
    D.22256 = *D.22253;
    D.22316 = (float) D.22256;
    D.22250 = (long unsigned int) i;
    D.22251 = D.22250 * 4;
    D.22252 = slots_available + D.22251;
    D.22317 = *D.22252;
    D.22318 = (float) D.22317;
    usage = D.22316 / D.22318;
    D.22250 = (long unsigned int) i;
    D.22251 = D.22250 * 4;
    D.22254 = num_blocks + D.22251;
    D.22255 = *D.22254;
    if (D.22255 > 5) goto <D.22321>; else goto <D.22319>;
    <D.22321>:
    evacuation_threshold.148 = evacuation_threshold;
    if (usage < evacuation_threshold.148) goto <D.22323>; else goto <D.22319>;
    <D.22323>:
    evacuate_block_obj_sizes.149 = evacuate_block_obj_sizes;
    D.22250 = (long unsigned int) i;
    D.22251 = D.22250 * 4;
    D.22325 = evacuate_block_obj_sizes.149 + D.22251;
    *D.22325 = 1;
    goto <D.22320>;
    <D.22319>:
    evacuate_block_obj_sizes.149 = evacuate_block_obj_sizes;
    D.22250 = (long unsigned int) i;
    D.22251 = D.22250 * 4;
    D.22325 = evacuate_block_obj_sizes.149 + D.22251;
    *D.22325 = 0;
    <D.22320>:
    {
      mword total_bytes;

      block_obj_sizes.150 = block_obj_sizes;
      D.22250 = (long unsigned int) i;
      D.22251 = D.22250 * 4;
      D.22327 = block_obj_sizes.150 + D.22251;
      D.22328 = *D.22327;
      D.22250 = (long unsigned int) i;
      D.22251 = D.22250 * 4;
      D.22252 = slots_available + D.22251;
      D.22317 = *D.22252;
      D.22329 = D.22328 * D.22317;
      total_bytes = (mword) D.22329;
      total_evacuate_heap = total_evacuate_heap + total_bytes;
      evacuate_block_obj_sizes.149 = evacuate_block_obj_sizes;
      D.22250 = (long unsigned int) i;
      D.22251 = D.22250 * 4;
      D.22325 = evacuate_block_obj_sizes.149 + D.22251;
      D.22330 = *D.22325;
      if (D.22330 != 0) goto <D.22331>; else goto <D.22332>;
      <D.22331>:
      block_obj_sizes.150 = block_obj_sizes;
      D.22250 = (long unsigned int) i;
      D.22251 = D.22250 * 4;
      D.22327 = block_obj_sizes.150 + D.22251;
      D.22328 = *D.22327;
      D.22250 = (long unsigned int) i;
      D.22251 = D.22250 * 4;
      D.22253 = slots_used + D.22251;
      D.22256 = *D.22253;
      D.22333 = D.22328 * D.22256;
      D.22334 = (long unsigned int) D.22333;
      D.22335 = total_bytes - D.22334;
      total_evacuate_saved = D.22335 + total_evacuate_saved;
      <D.22332>:
    }
  }
  i = i + 1;
  <D.19994>:
  num_block_obj_sizes.142 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.142) goto <D.19993>; else goto <D.19995>;
  <D.19995>:
  D.22336 = (float) total_evacuate_saved;
  D.22337 = (float) total_evacuate_heap;
  D.22338 = D.22336 / D.22337;
  concurrent_evacuation_threshold.151 = concurrent_evacuation_threshold;
  D.22340 = 1.0e+0 - concurrent_evacuation_threshold.151;
  D.22341 = D.22338 > D.22340;
  want_evacuation.152 = (int) D.22341;
  want_evacuation = want_evacuation.152;
  have_swept = 1;
}


bitcount (mword d)
{
  int D.22345;
  unsigned int D.22347;
  int D.22348;
  int D.22349;
  int count;

  count = 0;
  if (1 != 0) goto <D.22343>; else goto <D.22344>;
  <D.22343>:
  D.22345 = __builtin_popcountl (d);
  count = D.22345 + count;
  goto <D.22346>;
  <D.22344>:
  D.22347 = (unsigned int) d;
  D.22348 = __builtin_popcount (D.22347);
  count = D.22348 + count;
  <D.22346>:
  D.22349 = count;
  return D.22349;
}


update_heap_boundaries_for_block (struct MSBlockInfo * block)
{
  char * D.22351;
  long unsigned int D.22352;
  long unsigned int D.22353;

  D.22351 = block->block;
  D.22352 = (long unsigned int) D.22351;
  D.22353 = D.22352 + 16384;
  D.22351 = block->block;
  D.22352 = (long unsigned int) D.22351;
  sgen_update_heap_boundaries (D.22352, D.22353);
}


ms_free_block (void * block)
{
  void * D.22354;
  int D.22355;
  int D.22356;
  void * empty;

  sgen_memgov_release_space (16384, 1);
  memset (block, 0, 16384);
  <D.19316>:
  empty = empty_blocks;
  MEM[(void * *)block] = empty;
  D.22354 = InterlockedCompareExchangePointer (&empty_blocks, block, empty);
  if (D.22354 != empty) goto <D.19316>; else goto <D.19317>;
  <D.19317>:
  {
    int __old_x;

    <D.19319>:
    __old_x = num_empty_blocks;
    D.22355 = __old_x + 1;
    D.22356 = InterlockedCompareExchange (&num_empty_blocks, D.22355, __old_x);
    if (D.22356 != __old_x) goto <D.19319>; else goto <D.19320>;
    <D.19320>:
  }
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.22357;
  long unsigned int exch.153;
  long unsigned int comp.154;
  long unsigned int D.22360;

  exch.153 = (long unsigned int) exch;
  comp.154 = (long unsigned int) comp;
  D.22360 = __sync_val_compare_and_swap_8 (dest, comp.154, exch.153);
  D.22357 = (void *) D.22360;
  return D.22357;
}


InterlockedCompareExchange (volatile gint32 * dest, gint32 exch, gint32 comp)
{
  gint32 D.22362;
  unsigned int exch.155;
  unsigned int comp.156;
  unsigned int D.22365;

  exch.155 = (unsigned int) exch;
  comp.156 = (unsigned int) comp;
  D.22365 = __sync_val_compare_and_swap_4 (dest, comp.156, exch.155);
  D.22362 = (gint32) D.22365;
  return D.22362;
}


major_init_to_space ()
{

}


major_get_cardtable_mod_union_for_object (char * obj)
{
  long unsigned int obj.157;
  long unsigned int D.22368;
  struct MSBlockHeader * D.22369;
  guint8 * D.22370;
  guint8 * D.22371;
  long int obj.158;
  char * D.22373;
  void * D.22374;
  long int D.22375;
  long int D.22376;
  long int D.22377;
  sizetype D.22378;
  struct MSBlockInfo * block;

  obj.157 = (long unsigned int) obj;
  D.22368 = obj.157 & 18446744073709535232;
  D.22369 = (struct MSBlockHeader *) D.22368;
  block = D.22369->info;
  D.22371 = block->cardtable_mod_union;
  obj.158 = (long int) obj;
  D.22373 = block->block;
  D.22374 = sgen_card_table_align_pointer (D.22373);
  D.22375 = (long int) D.22374;
  D.22376 = obj.158 - D.22375;
  D.22377 = D.22376 >> 9;
  D.22378 = (sizetype) D.22377;
  D.22370 = D.22371 + D.22378;
  return D.22370;
}


update_cardtable_mod_union ()
{
  char * D.22380;
  guint8 * D.22381;
  guint8 * D.22382;
  long unsigned int num_cards.159;
  _Bool D.22384;
  long int D.22385;
  long int D.22386;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.20197>;
  <D.20196>:
  {
    size_t num_cards;

    try
      {
        D.22380 = block->block;
        D.22381 = block->cardtable_mod_union;
        D.22382 = sgen_card_table_update_mod_union (D.22381, D.22380, 16384, &num_cards);
        block->cardtable_mod_union = D.22382;
        num_cards.159 = num_cards;
        D.22384 = num_cards.159 != 32;
        D.22385 = (long int) D.22384;
        D.22386 = __builtin_expect (D.22385, 0);
        if (D.22386 != 0) goto <D.22387>; else goto <D.22388>;
        <D.22387>:
        monoeg_g_log (0B, 4, "Number of cards calculation is wrong");
        <D.20195>:
        goto <D.20195>;
        <D.22388>:
      }
    finally
      {
        num_cards = {CLOBBER};
      }
  }
  block = block->next;
  <D.20197>:
  if (block != 0B) goto <D.20196>; else goto <D.20198>;
  <D.20198>:
}


major_iterate_live_block_ranges (void (*sgen_cardtable_block_callback) (mword, mword) callback)
{
  unsigned char D.22389;
  unsigned char D.22390;
  char * D.22393;
  long unsigned int D.22394;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.20128>;
  <D.20127>:
  D.22389 = BIT_FIELD_REF <*block, 8, 96>;
  D.22390 = D.22389 & 2;
  if (D.22390 != 0) goto <D.22391>; else goto <D.22392>;
  <D.22391>:
  D.22393 = block->block;
  D.22394 = (long unsigned int) D.22393;
  callback (D.22394, 16384);
  <D.22392>:
  block = block->next;
  <D.20128>:
  if (block != 0B) goto <D.20127>; else goto <D.20129>;
  <D.20129>:
}


major_scan_card_table (gboolean mod_union, struct SgenGrayQueue * queue)
{
  struct SgenObjectOperations * D.22395;
  int concurrent_mark.160;
  _Bool D.22399;
  long int D.22400;
  long int D.22401;
  unsigned char D.22404;
  unsigned char D.22405;
  long unsigned int block_start.161;
  unsigned char D.22416;
  void * D.22420;
  char * D.22422;
  char * D.22424;
  long int obj.162;
  long int obj.163;
  long int D.22429;
  long int D.22430;
  long int D.22431;
  long unsigned int D.22435;
  long int D.22436;
  long unsigned int D.22437;
  long unsigned int D.22438;
  long int base.164;
  long int D.22441;
  long int D.22442;
  sizetype D.22443;
  guint8 * D.22444;
  long unsigned int D.22445;
  sizetype D.22446;
  long int card_data.165;
  long int card_base.166;
  long int D.22455;
  int D.22456;
  sizetype D.22457;
  unsigned char D.22458;
  long int start.167;
  char * D.22467;
  long int D.22468;
  long int D.22469;
  long int D.22470;
  long int D.22471;
  int D.22472;
  sizetype D.22473;
  sizetype D.22474;
  void * D.22476;
  char * D.22478;
  long int obj.168;
  long int obj.169;
  long int D.22484;
  long int D.22485;
  long int D.22486;
  long unsigned int D.22490;
  long int D.22491;
  long unsigned int D.22492;
  long unsigned int D.22493;
  struct MSBlockInfo * block;
  void (*ScanObjectFunc) (char *, struct SgenGrayQueue *) scan_func;
  void next_large = <<< error >>>;
  void next_small = <<< error >>>;

  D.22395 = sgen_get_current_object_ops ();
  scan_func = D.22395->scan_object;
  concurrent_mark.160 = concurrent_mark;
  if (concurrent_mark.160 == 0) goto <D.22397>; else goto <D.22398>;
  <D.22397>:
  D.22399 = mod_union != 0;
  D.22400 = (long int) D.22399;
  D.22401 = __builtin_expect (D.22400, 0);
  if (D.22401 != 0) goto <D.22402>; else goto <D.22403>;
  <D.22402>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 2225, "!mod_union");
  <D.22403>:
  <D.22398>:
  block = all_blocks;
  goto <D.20188>;
  <D.20187>:
  {
    int block_obj_size;
    char * block_start;

    D.22404 = BIT_FIELD_REF <*block, 8, 96>;
    D.22405 = D.22404 & 2;
    if (D.22405 == 0) goto <D.22406>; else goto <D.22407>;
    <D.22406>:
    // predicted unlikely by continue predictor.
    goto <D.20154>;
    <D.22407>:
    block_obj_size = block->obj_size;
    block_start = block->block;
    if (block_obj_size > 511) goto <D.22408>; else goto <D.22409>;
    <D.22408>:
    {
      guint8 * cards;
      char * obj;
      char * end;
      char * base;

      if (mod_union != 0) goto <D.22410>; else goto <D.22411>;
      <D.22410>:
      cards = block->cardtable_mod_union;
      if (cards == 0B) goto <D.22412>; else goto <D.22413>;
      <D.22412>:
      // predicted unlikely by continue predictor.
      goto <D.20154>;
      <D.22413>:
      goto <D.22414>;
      <D.22411>:
      block_start.161 = (long unsigned int) block_start;
      cards = sgen_card_table_get_shadow_card_address (block_start.161);
      <D.22414>:
      obj = block_start + 16;
      end = block_start + 16384;
      base = sgen_card_table_align_pointer (obj);
      goto <D.20165>;
      <D.20164>:
      {
        int card_offset;

        D.22404 = BIT_FIELD_REF <*block, 8, 96>;
        D.22416 = D.22404 & 16;
        if (D.22416 == 0) goto <D.22417>; else goto <D.22418>;
        <D.22417>:
        sweep_block (block, 0);
        <D.22418>:
        D.22420 = MEM[(void * *)obj];
        if (D.22420 == 0B) goto next_large; else goto <D.22421>;
        <D.22421>:
        D.22422 = MEM[(char * *)obj];
        if (D.22422 >= block_start) goto <D.22423>; else goto <D.22419>;
        <D.22423>:
        D.22422 = MEM[(char * *)obj];
        D.22424 = block_start + 16384;
        if (D.22422 < D.22424) goto next_large; else goto <D.22419>;
        <D.22419>:
        if (mod_union != 0) goto <D.22425>; else goto <D.22426>;
        <D.22425>:
        {
          int w;
          int b;

          {
            int i;

            obj.162 = (long int) obj;
            obj.163 = (long int) obj;
            D.22429 = obj.163 & -16384;
            D.22430 = obj.162 - D.22429;
            D.22431 = D.22430 >> 3;
            i = (int) D.22431;
            if (0 != 0) goto <D.22432>; else goto <D.22433>;
            <D.22432>:
            w = i >> 5;
            b = i & 31;
            goto <D.22434>;
            <D.22433>:
            w = i >> 6;
            b = i & 63;
            <D.22434>:
          }
          D.22435 = block->mark_words[w];
          D.22436 = 1 << b;
          D.22437 = (long unsigned int) D.22436;
          D.22438 = D.22435 & D.22437;
          if (D.22438 == 0) goto next_large; else goto <D.22439>;
          <D.22439>:
        }
        <D.22426>:
        obj.162 = (long int) obj;
        base.164 = (long int) base;
        D.22441 = obj.162 - base.164;
        D.22442 = D.22441 >> 9;
        card_offset = (int) D.22442;
        D.22443 = (sizetype) card_offset;
        D.22444 = cards + D.22443;
        D.22445 = (long unsigned int) block_obj_size;
        sgen_cardtable_scan_object (obj, D.22445, D.22444, mod_union, queue);
        next_large:
        D.22446 = (sizetype) block_obj_size;
        obj = obj + D.22446;
      }
      <D.20165>:
      if (obj < end) goto <D.20164>; else goto <D.20166>;
      <D.20166>:
    }
    goto <D.22447>;
    <D.22409>:
    {
      guint8 * card_data;
      guint8 * card_base;
      guint8 * card_data_end;

      if (mod_union != 0) goto <D.22448>; else goto <D.22449>;
      <D.22448>:
      card_base = block->cardtable_mod_union;
      card_data = card_base;
      if (card_data == 0B) goto <D.22450>; else goto <D.22451>;
      <D.22450>:
      // predicted unlikely by continue predictor.
      goto <D.20154>;
      <D.22451>:
      goto <D.22452>;
      <D.22449>:
      block_start.161 = (long unsigned int) block_start;
      card_base = sgen_card_table_get_shadow_card_address (block_start.161);
      card_data = card_base;
      <D.22452>:
      card_data_end = card_data + 32;
      card_data = initial_skip_card (card_data);
      goto <D.20185>;
      <D.20184>:
      {
        int index;
        int idx;
        char * start;
        char * end;
        char * first_obj;
        char * obj;

        card_data.165 = (long int) card_data;
        card_base.166 = (long int) card_base;
        D.22455 = card_data.165 - card_base.166;
        idx = (int) D.22455;
        D.22456 = idx * 512;
        D.22457 = (sizetype) D.22456;
        start = block_start + D.22457;
        end = start + 512;
        D.22458 = *card_data;
        if (D.22458 == 0) goto <D.22459>; else goto <D.22460>;
        <D.22459>:
        // predicted unlikely by continue predictor.
        goto <D.20176>;
        <D.22460>:
        D.22404 = BIT_FIELD_REF <*block, 8, 96>;
        D.22416 = D.22404 & 16;
        if (D.22416 == 0) goto <D.22461>; else goto <D.22462>;
        <D.22461>:
        sweep_block (block, 0);
        <D.22462>:
        sgen_card_table_prepare_card_for_scanning (card_data);
        if (idx == 0) goto <D.22463>; else goto <D.22464>;
        <D.22463>:
        index = 0;
        goto <D.22465>;
        <D.22464>:
        start.167 = (long int) start;
        D.22467 = block_start + 16;
        D.22468 = (long int) D.22467;
        D.22469 = start.167 - D.22468;
        D.22470 = (long int) block_obj_size;
        D.22471 = D.22469 / D.22470;
        index = (int) D.22471;
        <D.22465>:
        D.22472 = block_obj_size * index;
        D.22473 = (sizetype) D.22472;
        D.22474 = D.22473 + 16;
        first_obj = block_start + D.22474;
        obj = first_obj;
        goto <D.20182>;
        <D.20181>:
        D.22476 = MEM[(void * *)obj];
        if (D.22476 == 0B) goto next_small; else goto <D.22477>;
        <D.22477>:
        D.22478 = MEM[(char * *)obj];
        if (D.22478 >= block_start) goto <D.22479>; else goto <D.22475>;
        <D.22479>:
        D.22478 = MEM[(char * *)obj];
        D.22424 = block_start + 16384;
        if (D.22478 < D.22424) goto next_small; else goto <D.22475>;
        <D.22475>:
        if (mod_union != 0) goto <D.22480>; else goto <D.22481>;
        <D.22480>:
        {
          int w;
          int b;

          {
            int i;

            obj.168 = (long int) obj;
            obj.169 = (long int) obj;
            D.22484 = obj.169 & -16384;
            D.22485 = obj.168 - D.22484;
            D.22486 = D.22485 >> 3;
            i = (int) D.22486;
            if (0 != 0) goto <D.22487>; else goto <D.22488>;
            <D.22487>:
            w = i >> 5;
            b = i & 31;
            goto <D.22489>;
            <D.22488>:
            w = i >> 6;
            b = i & 63;
            <D.22489>:
          }
          D.22490 = block->mark_words[w];
          D.22491 = 1 << b;
          D.22492 = (long unsigned int) D.22491;
          D.22493 = D.22490 & D.22492;
          if (D.22493 == 0) goto next_small; else goto <D.22494>;
          <D.22494>:
        }
        <D.22481>:
        scan_func (obj, queue);
        next_small:
        D.22446 = (sizetype) block_obj_size;
        obj = obj + D.22446;
        <D.20182>:
        if (obj < end) goto <D.20181>; else goto <D.20183>;
        <D.20183>:
      }
      <D.20176>:
      card_data = card_data + 1;
      <D.20185>:
      if (card_data < card_data_end) goto <D.20184>; else goto <D.20186>;
      <D.20186>:
    }
    <D.22447>:
  }
  <D.20154>:
  block = block->next;
  <D.20188>:
  if (block != 0B) goto <D.20187>; else goto <D.20189>;
  <D.20189>:
}


sgen_card_table_get_shadow_card_address (mword address)
{
  guint8 * D.22495;
  guint8 * sgen_shadow_cardtable.170;
  long unsigned int D.22497;
  sizetype D.22498;

  sgen_shadow_cardtable.170 = sgen_shadow_cardtable;
  D.22497 = address >> 9;
  D.22498 = D.22497 & 8388607;
  D.22495 = sgen_shadow_cardtable.170 + D.22498;
  return D.22495;
}


initial_skip_card (guint8 * card_data)
{
  long unsigned int D.22500;
  long unsigned int D.22501;
  mword * D.22502;
  guint8 * D.22506;
  int D.22507;
  sizetype D.22508;
  long long int card.171;
  int D.22510;
  int D.22511;
  int D.22512;
  sizetype D.22513;
  sizetype D.22514;
  mword * cards;
  mword card;
  int i;

  cards = card_data;
  i = 0;
  goto <D.20138>;
  <D.20137>:
  D.22500 = (long unsigned int) i;
  D.22501 = D.22500 * 8;
  D.22502 = cards + D.22501;
  card = *D.22502;
  if (card != 0) goto <D.20136>; else goto <D.22503>;
  <D.22503>:
  i = i + 1;
  <D.20138>:
  if (i <= 3) goto <D.20137>; else goto <D.20136>;
  <D.20136>:
  if (i == 4) goto <D.22504>; else goto <D.22505>;
  <D.22504>:
  D.22506 = card_data + 32;
  return D.22506;
  <D.22505>:
  D.22507 = i * 8;
  D.22508 = (sizetype) D.22507;
  card.171 = (long long int) card;
  D.22510 = __builtin_ffsll (card.171);
  D.22511 = D.22510 + -1;
  D.22512 = D.22511 / 8;
  D.22513 = (sizetype) D.22512;
  D.22514 = D.22508 + D.22513;
  D.22506 = card_data + D.22514;
  return D.22506;
}


sgen_card_table_prepare_card_for_scanning (guint8 * card)
{

}


pin_major_object (char * obj, struct SgenGrayQueue * queue)
{
  int concurrent_mark.172;
  long unsigned int obj.173;
  long unsigned int D.22520;
  struct MSBlockHeader * D.22521;
  long int obj.174;
  long int obj.175;
  long int D.22524;
  long int D.22525;
  long int D.22526;
  long unsigned int D.22532;
  long int D.22533;
  long unsigned int D.22534;
  long unsigned int D.22535;
  long unsigned int D.22538;
  unsigned char D.22539;
  unsigned char D.22540;
  int iftmp.176;
  struct GrayQueueSection * D.22547;
  int D.22549;
  _Bool D.22550;
  long int D.22551;
  long int D.22552;
  int D.22556;
  int D.22557;
  struct MSBlockInfo * block;

  concurrent_mark.172 = concurrent_mark;
  if (concurrent_mark.172 != 0) goto <D.22517>; else goto <D.22518>;
  <D.22517>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-marksweep.c", 1107);
  <D.22518>:
  obj.173 = (long unsigned int) obj;
  D.22520 = obj.173 & 18446744073709535232;
  D.22521 = (struct MSBlockHeader *) D.22520;
  block = D.22521->info;
  block->has_pinned = 1;
  {
    int __word;
    int __bit;

    {
      int i;

      obj.174 = (long int) obj;
      obj.175 = (long int) obj;
      D.22524 = obj.175 & -16384;
      D.22525 = obj.174 - D.22524;
      D.22526 = D.22525 >> 3;
      i = (int) D.22526;
      if (0 != 0) goto <D.22527>; else goto <D.22528>;
      <D.22527>:
      __word = i >> 5;
      __bit = i & 31;
      goto <D.22529>;
      <D.22528>:
      __word = i >> 6;
      __bit = i & 63;
      <D.22529>:
    }
    if (0 != 0) goto <D.22530>; else goto <D.22531>;
    <D.22530>:
    monoeg_g_log (0B, 4, "object %p not allocated", obj);
    <D.19508>:
    goto <D.19508>;
    <D.22531>:
    D.22532 = block->mark_words[__word];
    D.22533 = 1 << __bit;
    D.22534 = (long unsigned int) D.22533;
    D.22535 = D.22532 & D.22534;
    if (D.22535 == 0) goto <D.22536>; else goto <D.22537>;
    <D.22536>:
    D.22532 = block->mark_words[__word];
    D.22533 = 1 << __bit;
    D.22534 = (long unsigned int) D.22533;
    D.22538 = D.22532 | D.22534;
    block->mark_words[__word] = D.22538;
    D.22539 = BIT_FIELD_REF <*block, 8, 96>;
    D.22540 = D.22539 & 2;
    if (D.22540 != 0) goto <D.22541>; else goto <D.22542>;
    <D.22541>:
    D.22547 = queue->first;
    if (D.22547 == 0B) goto <D.22544>; else goto <D.22548>;
    <D.22548>:
    D.22547 = queue->first;
    D.22549 = D.22547->end;
    if (D.22549 == 125) goto <D.22544>; else goto <D.22545>;
    <D.22544>:
    iftmp.176 = 1;
    goto <D.22546>;
    <D.22545>:
    iftmp.176 = 0;
    <D.22546>:
    D.22550 = iftmp.176 != 0;
    D.22551 = (long int) D.22550;
    D.22552 = __builtin_expect (D.22551, 0);
    if (D.22552 != 0) goto <D.22553>; else goto <D.22554>;
    <D.22553>:
    sgen_gray_object_enqueue (queue, obj);
    goto <D.22555>;
    <D.22554>:
    D.22547 = queue->first;
    D.22547 = queue->first;
    D.22549 = D.22547->end;
    D.22556 = D.22549;
    D.22557 = D.22556 + 1;
    D.22547->end = D.22557;
    D.22547->objects[D.22556] = obj;
    <D.22555>:
    __builtin_prefetch (obj);
    <D.22542>:
    <D.22537>:
  }
}


major_pin_objects (struct SgenGrayQueue * queue)
{
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.20073>;
  <D.20072>:
  mark_pinned_objects_in_block (block, queue);
  block = block->next;
  <D.20073>:
  if (block != 0B) goto <D.20072>; else goto <D.20074>;
  <D.20074>:
}


mark_pinned_objects_in_block (struct MSBlockInfo * block, struct SgenGrayQueue * queue)
{
  int D.22558;
  void * * D.22561;
  long unsigned int D.22562;
  long unsigned int D.22563;
  void * * D.22564;
  void * D.22565;
  long int D.22566;
  char * D.22567;
  char * D.22568;
  long int D.22569;
  long int D.22570;
  int D.22571;
  long int D.22572;
  long int D.22573;
  int D.22576;
  int D.22579;
  sizetype D.22580;
  sizetype D.22581;
  char * D.22582;
  long int D.22583;
  long int D.22584;
  long int D.22585;
  long int D.22586;
  long int D.22587;
  long unsigned int D.22593;
  long int D.22594;
  long unsigned int D.22595;
  long unsigned int D.22596;
  void * D.22599;
  char * D.22602;
  char * D.22604;
  long unsigned int D.22605;
  unsigned char D.22606;
  unsigned char D.22607;
  int iftmp.177;
  struct GrayQueueSection * D.22614;
  int D.22616;
  _Bool D.22617;
  long int D.22618;
  long int D.22619;
  int D.22623;
  int D.22624;
  int i;
  int last_index;

  last_index = -1;
  D.22558 = block->pin_queue_num_entries;
  if (D.22558 == 0) goto <D.22559>; else goto <D.22560>;
  <D.22559>:
  return;
  <D.22560>:
  block->has_pinned = 1;
  i = 0;
  goto <D.19922>;
  <D.19921>:
  {
    int index;

    D.22561 = block->pin_queue_start;
    D.22562 = (long unsigned int) i;
    D.22563 = D.22562 * 8;
    D.22564 = D.22561 + D.22563;
    D.22565 = *D.22564;
    D.22566 = (long int) D.22565;
    D.22567 = block->block;
    D.22568 = D.22567 + 16;
    D.22569 = (long int) D.22568;
    D.22570 = D.22566 - D.22569;
    D.22571 = block->obj_size;
    D.22572 = (long int) D.22571;
    D.22573 = D.22570 / D.22572;
    index = (int) D.22573;
    if (0 != 0) goto <D.22574>; else goto <D.22575>;
    <D.22574>:
    D.22571 = block->obj_size;
    D.22576 = 16368 / D.22571;
    D.22561 = block->pin_queue_start;
    D.22562 = (long unsigned int) i;
    D.22563 = D.22562 * 8;
    D.22564 = D.22561 + D.22563;
    D.22565 = *D.22564;
    monoeg_g_log (0B, 4, "invalid object %p index %d max-index %d", D.22565, index, D.22576);
    <D.19916>:
    goto <D.19916>;
    <D.22575>:
    if (index == last_index) goto <D.22577>; else goto <D.22578>;
    <D.22577>:
    // predicted unlikely by continue predictor.
    goto <D.19917>;
    <D.22578>:
    {
      int __word;
      int __bit;

      {
        int i;

        D.22567 = block->block;
        D.22571 = block->obj_size;
        D.22579 = D.22571 * index;
        D.22580 = (sizetype) D.22579;
        D.22581 = D.22580 + 16;
        D.22582 = D.22567 + D.22581;
        D.22583 = (long int) D.22582;
        D.22567 = block->block;
        D.22571 = block->obj_size;
        D.22579 = D.22571 * index;
        D.22580 = (sizetype) D.22579;
        D.22581 = D.22580 + 16;
        D.22582 = D.22567 + D.22581;
        D.22584 = (long int) D.22582;
        D.22585 = D.22584 & -16384;
        D.22586 = D.22583 - D.22585;
        D.22587 = D.22586 >> 3;
        i = (int) D.22587;
        if (0 != 0) goto <D.22588>; else goto <D.22589>;
        <D.22588>:
        __word = i >> 5;
        __bit = i & 31;
        goto <D.22590>;
        <D.22589>:
        __word = i >> 6;
        __bit = i & 63;
        <D.22590>:
      }
      D.22593 = block->mark_words[__word];
      D.22594 = 1 << __bit;
      D.22595 = (long unsigned int) D.22594;
      D.22596 = D.22593 & D.22595;
      if (D.22596 == 0) goto <D.22597>; else goto <D.22598>;
      <D.22597>:
      D.22567 = block->block;
      D.22571 = block->obj_size;
      D.22579 = D.22571 * index;
      D.22580 = (sizetype) D.22579;
      D.22581 = D.22580 + 16;
      D.22582 = D.22567 + D.22581;
      D.22599 = MEM[(void * *)D.22582];
      if (D.22599 != 0B) goto <D.22600>; else goto <D.22601>;
      <D.22600>:
      D.22567 = block->block;
      D.22571 = block->obj_size;
      D.22579 = D.22571 * index;
      D.22580 = (sizetype) D.22579;
      D.22581 = D.22580 + 16;
      D.22582 = D.22567 + D.22581;
      D.22602 = MEM[(char * *)D.22582];
      D.22567 = block->block;
      if (D.22602 < D.22567) goto <D.22591>; else goto <D.22603>;
      <D.22603>:
      D.22567 = block->block;
      D.22571 = block->obj_size;
      D.22579 = D.22571 * index;
      D.22580 = (sizetype) D.22579;
      D.22581 = D.22580 + 16;
      D.22582 = D.22567 + D.22581;
      D.22602 = MEM[(char * *)D.22582];
      D.22567 = block->block;
      D.22604 = D.22567 + 16384;
      if (D.22602 >= D.22604) goto <D.22591>; else goto <D.22592>;
      <D.22591>:
      D.22593 = block->mark_words[__word];
      D.22594 = 1 << __bit;
      D.22595 = (long unsigned int) D.22594;
      D.22605 = D.22593 | D.22595;
      block->mark_words[__word] = D.22605;
      D.22606 = BIT_FIELD_REF <*block, 8, 96>;
      D.22607 = D.22606 & 2;
      if (D.22607 != 0) goto <D.22608>; else goto <D.22609>;
      <D.22608>:
      D.22614 = queue->first;
      if (D.22614 == 0B) goto <D.22611>; else goto <D.22615>;
      <D.22615>:
      D.22614 = queue->first;
      D.22616 = D.22614->end;
      if (D.22616 == 125) goto <D.22611>; else goto <D.22612>;
      <D.22611>:
      iftmp.177 = 1;
      goto <D.22613>;
      <D.22612>:
      iftmp.177 = 0;
      <D.22613>:
      D.22617 = iftmp.177 != 0;
      D.22618 = (long int) D.22617;
      D.22619 = __builtin_expect (D.22618, 0);
      if (D.22619 != 0) goto <D.22620>; else goto <D.22621>;
      <D.22620>:
      D.22567 = block->block;
      D.22571 = block->obj_size;
      D.22579 = D.22571 * index;
      D.22580 = (sizetype) D.22579;
      D.22581 = D.22580 + 16;
      D.22582 = D.22567 + D.22581;
      sgen_gray_object_enqueue (queue, D.22582);
      goto <D.22622>;
      <D.22621>:
      D.22614 = queue->first;
      D.22614 = queue->first;
      D.22616 = D.22614->end;
      D.22623 = D.22616;
      D.22624 = D.22623 + 1;
      D.22614->end = D.22624;
      D.22567 = block->block;
      D.22571 = block->obj_size;
      D.22579 = D.22571 * index;
      D.22580 = (sizetype) D.22579;
      D.22581 = D.22580 + 16;
      D.22582 = D.22567 + D.22581;
      D.22614->objects[D.22623] = D.22582;
      <D.22622>:
      D.22567 = block->block;
      D.22571 = block->obj_size;
      D.22579 = D.22571 * index;
      D.22580 = (sizetype) D.22579;
      D.22581 = D.22580 + 16;
      D.22582 = D.22567 + D.22581;
      __builtin_prefetch (D.22582);
      <D.22609>:
      <D.22592>:
      <D.22601>:
      <D.22598>:
    }
    last_index = index;
  }
  <D.19917>:
  i = i + 1;
  <D.19922>:
  D.22558 = block->pin_queue_num_entries;
  if (D.22558 > i) goto <D.19921>; else goto <D.19923>;
  <D.19923>:
}


major_find_pin_queue_start_ends (struct SgenGrayQueue * queue)
{
  int * D.22626;
  char * D.22627;
  void * D.22628;
  void * D.22629;
  void * * D.22630;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.20066>;
  <D.20065>:
  D.22626 = &block->pin_queue_num_entries;
  D.22627 = block->block;
  D.22628 = D.22627 + 16384;
  D.22627 = block->block;
  D.22629 = D.22627 + 16;
  D.22630 = sgen_find_optimized_pin_queue_area (D.22629, D.22628, D.22626);
  block->pin_queue_start = D.22630;
  block = block->next;
  <D.20066>:
  if (block != 0B) goto <D.20065>; else goto <D.20067>;
  <D.20067>:
}


major_free_non_pinned_object (char * obj, size_t size)
{
  free_object (obj, size, 0);
}


free_object (char * obj, size_t size, gboolean pinned)
{
  long unsigned int obj.178;
  long unsigned int D.22632;
  struct MSBlockHeader * D.22633;
  unsigned char D.22634;
  unsigned char D.22635;
  <unnamed-unsigned:1> D.22640;
  int D.22641;
  long int obj.179;
  long int obj.180;
  long int D.22646;
  long int D.22647;
  long int D.22648;
  void * * D.22654;
  _Bool D.22657;
  int D.22658;
  int D.22659;
  int D.22660;
  int D.22661;
  int iftmp.181;
  long unsigned int D.22663;
  long unsigned int D.22664;
  int D.22668;
  long unsigned int D.22671;
  long unsigned int D.22672;
  struct MSBlockInfo * * D.22673;
  struct MSBlockInfo * D.22674;
  struct MSBlockInfo * block;
  int word;
  int bit;

  obj.178 = (long unsigned int) obj;
  D.22632 = obj.178 & 18446744073709535232;
  D.22633 = (struct MSBlockHeader *) D.22632;
  block = D.22633->info;
  D.22634 = BIT_FIELD_REF <*block, 8, 96>;
  D.22635 = D.22634 & 16;
  if (D.22635 == 0) goto <D.22636>; else goto <D.22637>;
  <D.22636>:
  sweep_block (block, 0);
  <D.22637>:
  if (0 != 0) goto <D.22638>; else goto <D.22639>;
  <D.22638>:
  D.22640 = block->pinned;
  D.22641 = (int) D.22640;
  monoeg_g_log (0B, 4, "free-object pinning mixup object %p pinned %d block %p pinned %d", obj, pinned, block, D.22641);
  <D.19375>:
  goto <D.19375>;
  <D.22639>:
  if (0 != 0) goto <D.22642>; else goto <D.22643>;
  <D.22642>:
  monoeg_g_log (0B, 4, "object %p is already free", obj);
  <D.19376>:
  goto <D.19376>;
  <D.22643>:
  {
    int i;

    obj.179 = (long int) obj;
    obj.180 = (long int) obj;
    D.22646 = obj.180 & -16384;
    D.22647 = obj.179 - D.22646;
    D.22648 = D.22647 >> 3;
    i = (int) D.22648;
    if (0 != 0) goto <D.22649>; else goto <D.22650>;
    <D.22649>:
    word = i >> 5;
    bit = i & 31;
    goto <D.22651>;
    <D.22650>:
    word = i >> 6;
    bit = i & 63;
    <D.22651>:
  }
  if (0 != 0) goto <D.22652>; else goto <D.22653>;
  <D.22652>:
  monoeg_g_log (0B, 4, "object %p has mark bit set");
  <D.19378>:
  goto <D.19378>;
  <D.22653>:
  D.22654 = block->free_list;
  if (D.22654 == 0B) goto <D.22655>; else goto <D.22656>;
  <D.22655>:
  {
    struct MSBlockInfo * * free_blocks;
    int size_index;

    D.22657 = pinned != 0;
    D.22658 = (int) D.22657;
    D.22634 = BIT_FIELD_REF <*block, 8, 96>;
    D.22659 = (int) D.22634;
    D.22660 = D.22659 & 2;
    D.22661 = D.22658 | D.22660;
    free_blocks = free_block_lists[D.22661];
    D.22663 = size + 7;
    D.22664 = D.22663 >> 3;
    if (D.22664 <= 31) goto <D.22665>; else goto <D.22666>;
    <D.22665>:
    D.22663 = size + 7;
    D.22664 = D.22663 >> 3;
    iftmp.181 = fast_block_obj_size_indexes[D.22664];
    goto <D.22667>;
    <D.22666>:
    D.22668 = (int) size;
    iftmp.181 = ms_find_block_obj_size_index (D.22668);
    <D.22667>:
    size_index = iftmp.181;
    if (0 != 0) goto <D.22669>; else goto <D.22670>;
    <D.22669>:
    monoeg_g_log (0B, 4, "block %p doesn\'t have a free-list of object but belongs to a free-list of blocks");
    <D.19381>:
    goto <D.19381>;
    <D.22670>:
    D.22671 = (long unsigned int) size_index;
    D.22672 = D.22671 * 8;
    D.22673 = free_blocks + D.22672;
    D.22674 = *D.22673;
    block->next_free = D.22674;
    D.22671 = (long unsigned int) size_index;
    D.22672 = D.22671 * 8;
    D.22673 = free_blocks + D.22672;
    *D.22673 = block;
  }
  <D.22656>:
  memset (obj, 0, size);
  D.22654 = block->free_list;
  MEM[(void * *)obj] = D.22654;
  block->free_list = obj;
}


major_iterate_objects (gboolean non_pinned, gboolean pinned, void (*IterateObjectCallbackFunc) (char *, size_t, void *) callback, void * data)
{
  int D.22675;
  unsigned char D.22676;
  unsigned char D.22677;
  int lazy_sweep.182;
  char * D.22689;
  int D.22690;
  sizetype D.22691;
  sizetype D.22692;
  void * D.22695;
  char * D.22698;
  char * D.22700;
  long unsigned int D.22701;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.19439>;
  <D.19438>:
  {
    int count;
    int i;

    D.22675 = block->obj_size;
    count = 16368 / D.22675;
    D.22676 = BIT_FIELD_REF <*block, 8, 96>;
    D.22677 = D.22676 & 1;
    if (D.22677 != 0) goto <D.22678>; else goto <D.22679>;
    <D.22678>:
    if (pinned == 0) goto <D.22680>; else goto <D.22681>;
    <D.22680>:
    // predicted unlikely by continue predictor.
    goto <D.19433>;
    <D.22681>:
    <D.22679>:
    D.22676 = BIT_FIELD_REF <*block, 8, 96>;
    D.22677 = D.22676 & 1;
    if (D.22677 == 0) goto <D.22682>; else goto <D.22683>;
    <D.22682>:
    if (non_pinned == 0) goto <D.22684>; else goto <D.22685>;
    <D.22684>:
    // predicted unlikely by continue predictor.
    goto <D.19433>;
    <D.22685>:
    <D.22683>:
    lazy_sweep.182 = lazy_sweep;
    if (lazy_sweep.182 != 0) goto <D.22687>; else goto <D.22688>;
    <D.22687>:
    sweep_block (block, 0);
    <D.22688>:
    i = 0;
    goto <D.19436>;
    <D.19435>:
    {
      void * * obj;

      D.22689 = block->block;
      D.22675 = block->obj_size;
      D.22690 = D.22675 * i;
      D.22691 = (sizetype) D.22690;
      D.22692 = D.22691 + 16;
      obj = D.22689 + D.22692;
      D.22695 = *obj;
      if (D.22695 != 0B) goto <D.22696>; else goto <D.22697>;
      <D.22696>:
      D.22698 = MEM[(char * *)obj];
      D.22689 = block->block;
      if (D.22698 < D.22689) goto <D.22693>; else goto <D.22699>;
      <D.22699>:
      D.22698 = MEM[(char * *)obj];
      D.22689 = block->block;
      D.22700 = D.22689 + 16384;
      if (D.22698 >= D.22700) goto <D.22693>; else goto <D.22694>;
      <D.22693>:
      D.22675 = block->obj_size;
      D.22701 = (long unsigned int) D.22675;
      callback (obj, D.22701, data);
      <D.22694>:
      <D.22697>:
    }
    i = i + 1;
    <D.19436>:
    if (i < count) goto <D.19435>; else goto <D.19437>;
    <D.19437>:
  }
  <D.19433>:
  block = block->next;
  <D.19439>:
  if (block != 0B) goto <D.19438>; else goto <D.19440>;
  <D.19440>:
}


free_pinned_object (char * obj, size_t size)
{
  free_object (obj, size, 1);
}


major_alloc_object (struct MonoVTable * vtable, int size, gboolean has_references)
{
  void * D.22702;

  D.22702 = alloc_obj (vtable, size, 0, has_references);
  return D.22702;
}


alloc_obj (struct MonoVTable * vtable, int size, gboolean pinned, gboolean has_references)
{
  int iftmp.183;
  int D.22705;
  int D.22706;
  _Bool D.22710;
  int D.22711;
  int iftmp.184;
  int D.22716;
  long unsigned int D.22717;
  long unsigned int D.22718;
  struct MSBlockInfo * * D.22719;
  struct MSBlockInfo * D.22720;
  int D.22723;
  _Bool D.22724;
  long int D.22725;
  long int D.22726;
  void * D.22729;
  int size_index;
  struct MSBlockInfo * * free_blocks;
  void * obj;

  D.22705 = size + 7;
  D.22706 = D.22705 >> 3;
  if (D.22706 <= 31) goto <D.22707>; else goto <D.22708>;
  <D.22707>:
  D.22705 = size + 7;
  D.22706 = D.22705 >> 3;
  iftmp.183 = fast_block_obj_size_indexes[D.22706];
  goto <D.22709>;
  <D.22708>:
  iftmp.183 = ms_find_block_obj_size_index (size);
  <D.22709>:
  size_index = iftmp.183;
  D.22710 = pinned != 0;
  D.22711 = (int) D.22710;
  if (has_references != 0) goto <D.22713>; else goto <D.22714>;
  <D.22713>:
  iftmp.184 = 2;
  goto <D.22715>;
  <D.22714>:
  iftmp.184 = 0;
  <D.22715>:
  D.22716 = D.22711 | iftmp.184;
  free_blocks = free_block_lists[D.22716];
  D.22717 = (long unsigned int) size_index;
  D.22718 = D.22717 * 8;
  D.22719 = free_blocks + D.22718;
  D.22720 = *D.22719;
  if (D.22720 == 0B) goto <D.22721>; else goto <D.22722>;
  <D.22721>:
  D.22723 = ms_alloc_block (size_index, pinned, has_references);
  D.22724 = D.22723 == 0;
  D.22725 = (long int) D.22724;
  D.22726 = __builtin_expect (D.22725, 0);
  if (D.22726 != 0) goto <D.22727>; else goto <D.22728>;
  <D.22727>:
  D.22729 = 0B;
  return D.22729;
  <D.22728>:
  <D.22722>:
  obj = unlink_slot_from_free_list_uncontested (free_blocks, size_index);
  MEM[(struct MonoVTable * *)obj] = vtable;
  D.22729 = obj;
  return D.22729;
}


ms_alloc_block (int size_index, gboolean pinned, gboolean has_references)
{
  int * block_obj_sizes.185;
  long unsigned int D.22732;
  long unsigned int D.22733;
  int * D.22734;
  _Bool D.22735;
  int D.22736;
  int iftmp.186;
  int D.22741;
  int D.22742;
  gboolean D.22745;
  unsigned char D.22748;
  <unnamed-unsigned:1> D.22749;
  unsigned char D.22750;
  <unnamed-unsigned:1> D.22751;
  int D.22752;
  _Bool D.22753;
  void * D.22754;
  char * D.22755;
  sizetype D.22756;
  int D.22757;
  long unsigned int D.22758;
  struct MSBlockInfo * * D.22759;
  struct MSBlockInfo * D.22760;
  struct MSBlockInfo * all_blocks.187;
  int num_major_sections.188;
  int num_major_sections.189;
  int size;
  int count;
  struct MSBlockInfo * info;
  struct MSBlockHeader * header;
  struct MSBlockInfo * * free_blocks;
  char * obj_start;
  int i;

  block_obj_sizes.185 = block_obj_sizes;
  D.22732 = (long unsigned int) size_index;
  D.22733 = D.22732 * 4;
  D.22734 = block_obj_sizes.185 + D.22733;
  size = *D.22734;
  count = 16368 / size;
  D.22735 = pinned != 0;
  D.22736 = (int) D.22735;
  if (has_references != 0) goto <D.22738>; else goto <D.22739>;
  <D.22738>:
  iftmp.186 = 2;
  goto <D.22740>;
  <D.22739>:
  iftmp.186 = 0;
  <D.22740>:
  D.22741 = D.22736 | iftmp.186;
  free_blocks = free_block_lists[D.22741];
  D.22742 = sgen_memgov_try_alloc_space (16384, 1);
  if (D.22742 == 0) goto <D.22743>; else goto <D.22744>;
  <D.22743>:
  D.22745 = 0;
  return D.22745;
  <D.22744>:
  info = sgen_alloc_internal (16);
  if (0 != 0) goto <D.22746>; else goto <D.22747>;
  <D.22746>:
  monoeg_g_log (0B, 4, "block with %d objects, it must hold at least 2", count);
  <D.19333>:
  goto <D.19333>;
  <D.22747>:
  info->obj_size = size;
  info->obj_size_index = size_index;
  D.22748 = (unsigned char) pinned;
  D.22749 = (<unnamed-unsigned:1>) D.22748;
  info->pinned = D.22749;
  D.22750 = (unsigned char) has_references;
  D.22751 = (<unnamed-unsigned:1>) D.22750;
  info->has_references = D.22751;
  D.22748 = (unsigned char) pinned;
  D.22749 = (<unnamed-unsigned:1>) D.22748;
  info->has_pinned = D.22749;
  D.22752 = sgen_get_current_collection_generation ();
  D.22753 = D.22752 == 1;
  info->is_to_space = D.22753;
  info->swept = 1;
  D.22754 = ms_get_empty_block ();
  info->block = D.22754;
  header = info->block;
  header->info = info;
  info->cardtable_mod_union = 0B;
  update_heap_boundaries_for_block (info);
  D.22755 = info->block;
  obj_start = D.22755 + 16;
  info->free_list = obj_start;
  i = 0;
  goto <D.19336>;
  <D.19335>:
  {
    char * next_obj_start;

    D.22756 = (sizetype) size;
    next_obj_start = obj_start + D.22756;
    MEM[(void * *)obj_start] = next_obj_start;
    obj_start = next_obj_start;
  }
  i = i + 1;
  <D.19336>:
  D.22757 = count + -1;
  if (D.22757 > i) goto <D.19335>; else goto <D.19337>;
  <D.19337>:
  MEM[(void * *)obj_start] = 0B;
  D.22732 = (long unsigned int) size_index;
  D.22758 = D.22732 * 8;
  D.22759 = free_blocks + D.22758;
  D.22760 = *D.22759;
  info->next_free = D.22760;
  D.22732 = (long unsigned int) size_index;
  D.22758 = D.22732 * 8;
  D.22759 = free_blocks + D.22758;
  *D.22759 = info;
  all_blocks.187 = all_blocks;
  info->next = all_blocks.187;
  all_blocks = info;
  num_major_sections.188 = num_major_sections;
  num_major_sections.189 = num_major_sections.188 + 1;
  num_major_sections = num_major_sections.189;
  D.22745 = 1;
  return D.22745;
}


ms_get_empty_block ()
{
  void * empty_blocks.190;
  const char * iftmp.191;
  int D.22772;
  long unsigned int D.22773;
  void * D.22775;
  int D.22776;
  int D.22777;
  long long int D.22778;
  long long int stat_major_blocks_alloced.192;
  long long int stat_major_blocks_alloced.193;
  void * D.22782;
  int D.22783;
  int D.22784;
  long unsigned int block.194;
  long unsigned int D.22786;
  _Bool D.22787;
  long int D.22788;
  long int D.22789;
  void * D.22792;
  char * p;
  int i;
  void * block;
  void * empty;
  void * next;
  void retry = <<< error >>>;

  retry:
  empty_blocks.190 = empty_blocks;
  if (empty_blocks.190 == 0B) goto <D.22766>; else goto <D.22767>;
  <D.22766>:
  {
    int alloc_num;

    alloc_num = 32;
    <D.19298>:
    if (alloc_num == 1) goto <D.22769>; else goto <D.22770>;
    <D.22769>:
    iftmp.191 = "major heap section";
    goto <D.22771>;
    <D.22770>:
    iftmp.191 = 0B;
    <D.22771>:
    D.22772 = alloc_num * 16384;
    D.22773 = (long unsigned int) D.22772;
    p = sgen_alloc_os_memory_aligned (D.22773, 16384, 3, iftmp.191);
    if (p != 0B) goto <D.19297>; else goto <D.22774>;
    <D.22774>:
    alloc_num = alloc_num >> 1;
    goto <D.19298>;
    <D.19297>:
    i = 0;
    goto <D.19302>;
    <D.19301>:
    block = p;
    <D.19299>:
    empty = empty_blocks;
    MEM[(void * *)block] = empty;
    D.22775 = InterlockedCompareExchangePointer (&empty_blocks, block, empty);
    if (D.22775 != empty) goto <D.19299>; else goto <D.19300>;
    <D.19300>:
    p = p + 16384;
    i = i + 1;
    <D.19302>:
    if (i < alloc_num) goto <D.19301>; else goto <D.19303>;
    <D.19303>:
    {
      int __old_x;

      <D.19305>:
      __old_x = num_empty_blocks;
      D.22776 = __old_x + alloc_num;
      D.22777 = InterlockedCompareExchange (&num_empty_blocks, D.22776, __old_x);
      if (D.22777 != __old_x) goto <D.19305>; else goto <D.19306>;
      <D.19306>:
    }
    D.22778 = (long long int) alloc_num;
    stat_major_blocks_alloced.192 = stat_major_blocks_alloced;
    stat_major_blocks_alloced.193 = D.22778 + stat_major_blocks_alloced.192;
    stat_major_blocks_alloced = stat_major_blocks_alloced.193;
  }
  <D.22767>:
  <D.19307>:
  empty = empty_blocks;
  if (empty == 0B) goto retry; else goto <D.22781>;
  <D.22781>:
  block = empty;
  next = MEM[(void * *)block];
  D.22782 = InterlockedCompareExchangePointer (&empty_blocks, next, empty);
  if (D.22782 != empty) goto <D.19307>; else goto <D.19308>;
  <D.19308>:
  {
    int __old_x;

    <D.19310>:
    __old_x = num_empty_blocks;
    D.22783 = __old_x + -1;
    D.22784 = InterlockedCompareExchange (&num_empty_blocks, D.22783, __old_x);
    if (D.22784 != __old_x) goto <D.19310>; else goto <D.19311>;
    <D.19311>:
  }
  MEM[(void * *)block] = 0B;
  block.194 = (long unsigned int) block;
  D.22786 = block.194 & 16383;
  D.22787 = D.22786 != 0;
  D.22788 = (long int) D.22787;
  D.22789 = __builtin_expect (D.22788, 0);
  if (D.22789 != 0) goto <D.22790>; else goto <D.22791>;
  <D.22790>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 421, "!((mword)block & (MS_BLOCK_SIZE - 1))");
  <D.22791>:
  D.22792 = block;
  return D.22792;
}


unlink_slot_from_free_list_uncontested (struct MSBlockInfo * * free_blocks, int size_index)
{
  long unsigned int D.22794;
  long unsigned int D.22795;
  struct MSBlockInfo * * D.22796;
  unsigned char D.22799;
  unsigned char D.22800;
  _Bool D.22801;
  long int D.22802;
  long int D.22803;
  long long int stat_major_blocks_lazy_swept.195;
  long long int stat_major_blocks_lazy_swept.196;
  void * D.22810;
  void * * D.22811;
  struct MSBlockInfo * D.22814;
  void * D.22815;
  struct MSBlockInfo * block;
  void * obj;

  D.22794 = (long unsigned int) size_index;
  D.22795 = D.22794 * 8;
  D.22796 = free_blocks + D.22795;
  block = *D.22796;
  if (0 != 0) goto <D.22797>; else goto <D.22798>;
  <D.22797>:
  monoeg_g_log (0B, 4, "no free block to unlink from free_blocks %p size_index %d", free_blocks, size_index);
  <D.19351>:
  goto <D.19351>;
  <D.22798>:
  D.22799 = BIT_FIELD_REF <*block, 8, 96>;
  D.22800 = D.22799 & 16;
  D.22801 = D.22800 == 0;
  D.22802 = (long int) D.22801;
  D.22803 = __builtin_expect (D.22802, 0);
  if (D.22803 != 0) goto <D.22804>; else goto <D.22805>;
  <D.22804>:
  stat_major_blocks_lazy_swept.195 = stat_major_blocks_lazy_swept;
  stat_major_blocks_lazy_swept.196 = stat_major_blocks_lazy_swept.195 + 1;
  stat_major_blocks_lazy_swept = stat_major_blocks_lazy_swept.196;
  sweep_block (block, 0);
  <D.22805>:
  obj = block->free_list;
  if (0 != 0) goto <D.22808>; else goto <D.22809>;
  <D.22808>:
  monoeg_g_log (0B, 4, "block %p in free list had no available object to alloc from", block);
  <D.19352>:
  goto <D.19352>;
  <D.22809>:
  D.22810 = MEM[(void * *)obj];
  block->free_list = D.22810;
  D.22811 = block->free_list;
  if (D.22811 == 0B) goto <D.22812>; else goto <D.22813>;
  <D.22812>:
  D.22794 = (long unsigned int) size_index;
  D.22795 = D.22794 * 8;
  D.22796 = free_blocks + D.22795;
  D.22814 = block->next_free;
  *D.22796 = D.22814;
  block->next_free = 0B;
  <D.22813>:
  D.22815 = obj;
  return D.22815;
}


major_alloc_degraded (struct MonoVTable * vtable, size_t size)
{
  void * D.22817;
  long unsigned int D.22818;
  int D.22819;
  int D.22820;
  _Bool D.22821;
  long int D.22822;
  long int D.22823;
  int num_major_sections.197;
  _Bool D.22827;
  long int D.22828;
  long int D.22829;
  int D.22832;
  void * D.22833;
  void * obj;
  int old_num_sections;

  old_num_sections = num_major_sections;
  D.22817 = vtable->gc_descr;
  D.22818 = (long unsigned int) D.22817;
  D.22819 = sgen_gc_descr_has_references (D.22818);
  D.22820 = (int) size;
  obj = alloc_obj (vtable, D.22820, 0, D.22819);
  D.22821 = obj != 0B;
  D.22822 = (long int) D.22821;
  D.22823 = __builtin_expect (D.22822, 1);
  if (D.22823 != 0) goto <D.22824>; else goto <D.22825>;
  <D.22824>:
  num_major_sections.197 = num_major_sections;
  D.22827 = num_major_sections.197 < old_num_sections;
  D.22828 = (long int) D.22827;
  D.22829 = __builtin_expect (D.22828, 0);
  if (D.22829 != 0) goto <D.22830>; else goto <D.22831>;
  <D.22830>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 842, "num_major_sections >= old_num_sections");
  <D.22831>:
  num_major_sections.197 = num_major_sections;
  D.22832 = num_major_sections.197 - old_num_sections;
  sgen_register_major_sections_alloced (D.22832);
  <D.22825>:
  D.22833 = obj;
  return D.22833;
}


major_alloc_small_pinned_obj (struct MonoVTable * vtable, size_t size, gboolean has_references)
{
  int D.22835;
  void * D.22838;
  void * res;

  D.22835 = (int) size;
  res = alloc_obj (vtable, D.22835, 1, has_references);
  if (res == 0B) goto <D.22836>; else goto <D.22837>;
  <D.22836>:
  sgen_perform_collection (0, 1, "pinned alloc failure", 1);
  D.22835 = (int) size;
  res = alloc_obj (vtable, D.22835, 1, has_references);
  <D.22837>:
  D.22838 = res;
  return D.22838;
}


major_is_object_live (char * obj)
{
  int D.22840;
  gboolean D.22843;
  unsigned int D.22844;
  unsigned int D.22845;
  long unsigned int D.22846;
  long unsigned int obj.198;
  long unsigned int D.22850;
  struct MSBlockHeader * D.22851;
  long int obj.199;
  long int obj.200;
  long int D.22856;
  long int D.22857;
  long int D.22858;
  long unsigned int D.22862;
  long int D.22863;
  long unsigned int D.22864;
  long unsigned int D.22865;
  _Bool D.22866;
  struct MSBlockInfo * block;
  int word;
  int bit;
  mword objsize;

  D.22840 = sgen_ptr_in_nursery (obj);
  if (D.22840 != 0) goto <D.22841>; else goto <D.22842>;
  <D.22841>:
  D.22843 = 0;
  return D.22843;
  <D.22842>:
  D.22844 = sgen_safe_object_get_size (obj);
  D.22845 = D.22844 + 7;
  D.22846 = (long unsigned int) D.22845;
  objsize = D.22846 & 4294967288;
  if (objsize > 8000) goto <D.22847>; else goto <D.22848>;
  <D.22847>:
  D.22843 = 0;
  return D.22843;
  <D.22848>:
  obj.198 = (long unsigned int) obj;
  D.22850 = obj.198 & 18446744073709535232;
  D.22851 = (struct MSBlockHeader *) D.22850;
  block = D.22851->info;
  if (0 != 0) goto <D.22852>; else goto <D.22853>;
  <D.22852>:
  monoeg_g_log (0B, 4, "block %p is pinned, BTW why is this bad?");
  <D.19409>:
  goto <D.19409>;
  <D.22853>:
  {
    int i;

    obj.199 = (long int) obj;
    obj.200 = (long int) obj;
    D.22856 = obj.200 & -16384;
    D.22857 = obj.199 - D.22856;
    D.22858 = D.22857 >> 3;
    i = (int) D.22858;
    if (0 != 0) goto <D.22859>; else goto <D.22860>;
    <D.22859>:
    word = i >> 5;
    bit = i & 31;
    goto <D.22861>;
    <D.22860>:
    word = i >> 6;
    bit = i & 63;
    <D.22861>:
  }
  D.22862 = block->mark_words[word];
  D.22863 = 1 << bit;
  D.22864 = (long unsigned int) D.22863;
  D.22865 = D.22862 & D.22864;
  D.22866 = D.22865 != 0;
  D.22843 = (gboolean) D.22866;
  return D.22843;
}


major_alloc_heap (mword nursery_size, mword nursery_align, int the_nursery_bits)
{
  void * D.22871;
  char * start;

  if (nursery_align != 0) goto <D.22868>; else goto <D.22869>;
  <D.22868>:
  start = sgen_alloc_os_memory_aligned (nursery_size, nursery_align, 3, "nursery");
  goto <D.22870>;
  <D.22869>:
  start = sgen_alloc_os_memory (nursery_size, 3, "nursery");
  <D.22870>:
  D.22871 = start;
  return D.22871;
}


major_get_and_reset_num_major_objects_marked ()
{
  long long int D.22873;

  D.22873 = 0;
  return D.22873;
}


ms_calculate_block_obj_sizes (double factor, int * arr)
{
  double D.22875;
  double D.22876;
  int D.22877;
  int D.22878;
  long unsigned int D.22883;
  long unsigned int D.22884;
  int * D.22885;
  int D.22886;
  double target_size;
  int num_sizes;
  int last_size;

  target_size = 1.6e+1;
  num_sizes = 0;
  last_size = 0;
  <D.20028>:
  {
    int target_count;
    int size;

    D.22875 = 1.6368e+4 / target_size;
    D.22876 = ceil (D.22875);
    target_count = (int) D.22876;
    D.22877 = 16368 / target_count;
    D.22878 = D.22877 & -8;
    size = MIN_EXPR <D.22878, 8000>;
    if (size != last_size) goto <D.22879>; else goto <D.22880>;
    <D.22879>:
    if (arr != 0B) goto <D.22881>; else goto <D.22882>;
    <D.22881>:
    D.22883 = (long unsigned int) num_sizes;
    D.22884 = D.22883 * 4;
    D.22885 = arr + D.22884;
    *D.22885 = size;
    <D.22882>:
    num_sizes = num_sizes + 1;
    last_size = size;
    <D.22880>:
    target_size = target_size * factor;
  }
  if (last_size <= 7999) goto <D.20028>; else goto <D.20029>;
  <D.20029>:
  D.22886 = num_sizes;
  return D.22886;
}


alloc_free_block_lists (struct MSBlockInfo * * * lists)
{
  long unsigned int D.22888;
  long unsigned int D.22889;
  struct MSBlockInfo * * * D.22890;
  int num_block_obj_sizes.201;
  long unsigned int D.22892;
  long unsigned int D.22893;
  void * D.22894;
  int i;

  i = 0;
  goto <D.20208>;
  <D.20207>:
  D.22888 = (long unsigned int) i;
  D.22889 = D.22888 * 8;
  D.22890 = lists + D.22889;
  num_block_obj_sizes.201 = num_block_obj_sizes;
  D.22892 = (long unsigned int) num_block_obj_sizes.201;
  D.22893 = D.22892 * 8;
  D.22894 = sgen_alloc_internal_dynamic (D.22893, 15, 1);
  *D.22890 = D.22894;
  i = i + 1;
  <D.20208>:
  if (i <= 3) goto <D.20207>; else goto <D.20209>;
  <D.20209>:
}


ms_find_block_obj_size_index (int size)
{
  int * block_obj_sizes.202;
  long unsigned int D.22898;
  long unsigned int D.22899;
  int * D.22900;
  int D.22901;
  int D.22904;
  int num_block_obj_sizes.203;
  int i;

  if (0 != 0) goto <D.22895>; else goto <D.22896>;
  <D.22895>:
  monoeg_g_log (0B, 4, "size %d is bigger than max small object size %d", size, 8000);
  <D.19273>:
  goto <D.19273>;
  <D.22896>:
  i = 0;
  goto <D.19275>;
  <D.19274>:
  block_obj_sizes.202 = block_obj_sizes;
  D.22898 = (long unsigned int) i;
  D.22899 = D.22898 * 4;
  D.22900 = block_obj_sizes.202 + D.22899;
  D.22901 = *D.22900;
  if (D.22901 >= size) goto <D.22902>; else goto <D.22903>;
  <D.22902>:
  D.22904 = i;
  return D.22904;
  <D.22903>:
  i = i + 1;
  <D.19275>:
  num_block_obj_sizes.203 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.203) goto <D.19274>; else goto <D.19276>;
  <D.19276>:
  monoeg_g_log (0B, 4, "no object of size %d\n", size);
  <D.19277>:
  goto <D.19277>;
}


sgen_marksweep_conc_init (struct SgenMajorCollector * collector)
{
  sgen_marksweep_init_internal (collector, 1);
}