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;
  unsigned int num_block_obj_sizes.2;
  unsigned int D.20025;
  void * block_obj_sizes.3;
  int * block_obj_sizes.4;
  void * evacuate_block_obj_sizes.5;
  gboolean * evacuate_block_obj_sizes.6;
  unsigned int i.7;
  unsigned int D.20031;
  gboolean * D.20032;
  int D.20033;
  int D.20034;
  int iftmp.8;
  int D.20036;
  int D.20037;
  int D.20041;
  _Bool D.20042;
  long int D.20043;
  long int D.20044;
  int i;

  sgen_register_fixed_internal_mem_type (16, 296);
  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;
  num_block_obj_sizes.2 = (unsigned int) num_block_obj_sizes.1;
  D.20025 = num_block_obj_sizes.2 * 4;
  block_obj_sizes.3 = sgen_alloc_internal_dynamic (D.20025, 15, 1);
  block_obj_sizes = block_obj_sizes.3;
  block_obj_sizes.4 = block_obj_sizes;
  ms_calculate_block_obj_sizes (1.4142135623730951454746218587388284504413604736328125e+0, block_obj_sizes.4);
  num_block_obj_sizes.1 = num_block_obj_sizes;
  num_block_obj_sizes.2 = (unsigned int) num_block_obj_sizes.1;
  D.20025 = num_block_obj_sizes.2 * 4;
  evacuate_block_obj_sizes.5 = sgen_alloc_internal_dynamic (D.20025, 15, 1);
  evacuate_block_obj_sizes = evacuate_block_obj_sizes.5;
  i = 0;
  goto <D.20007>;
  <D.20006>:
  evacuate_block_obj_sizes.6 = evacuate_block_obj_sizes;
  i.7 = (unsigned int) i;
  D.20031 = i.7 * 4;
  D.20032 = evacuate_block_obj_sizes.6 + D.20031;
  *D.20032 = 0;
  i = i + 1;
  <D.20007>:
  num_block_obj_sizes.1 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.1) goto <D.20006>; else goto <D.20008>;
  <D.20008>:
  alloc_free_block_lists (&free_block_lists);
  i = 0;
  goto <D.20010>;
  <D.20009>:
  D.20033 = i * 8;
  D.20034 = ms_find_block_obj_size_index (D.20033);
  fast_block_obj_size_indexes[i] = D.20034;
  i = i + 1;
  <D.20010>:
  if (i <= 31) goto <D.20009>; else goto <D.20011>;
  <D.20011>:
  i = 0;
  goto <D.20013>;
  <D.20012>:
  D.20036 = i + 7;
  D.20037 = D.20036 >> 3;
  if (D.20037 <= 31) goto <D.20038>; else goto <D.20039>;
  <D.20038>:
  D.20036 = i + 7;
  D.20037 = D.20036 >> 3;
  iftmp.8 = fast_block_obj_size_indexes[D.20037];
  goto <D.20040>;
  <D.20039>:
  iftmp.8 = ms_find_block_obj_size_index (i);
  <D.20040>:
  D.20041 = ms_find_block_obj_size_index (i);
  D.20042 = iftmp.8 != D.20041;
  D.20043 = (long int) D.20042;
  D.20044 = __builtin_expect (D.20043, 0);
  if (D.20044 != 0) goto <D.20045>; else goto <D.20046>;
  <D.20045>:
  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.20046>:
  i = i + 1;
  <D.20013>:
  if (i <= 255) goto <D.20012>; else goto <D.20014>;
  <D.20014>:
  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);
  mono_counters_register ("# major blocks freed ideally", 515, &stat_major_blocks_freed_ideal);
  mono_counters_register ("# major blocks freed less ideally", 515, &stat_major_blocks_freed_less_ideal);
  mono_counters_register ("# major blocks freed individually", 515, &stat_major_blocks_freed_individual);
  mono_counters_register ("# major blocks allocated less ideally", 515, &stat_major_blocks_alloced_less_ideal);
  collector->section_size = 16384;
  collector->is_parallel = 0;
  concurrent_mark = is_concurrent;
  if (is_concurrent != 0) goto <D.20047>; else goto <D.20048>;
  <D.20047>:
  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.20049>;
  <D.20048>:
  collector->is_concurrent = 0;
  collector->want_synchronous_collection = 0B;
  <D.20049>:
  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.20050>; else goto <D.20051>;
  <D.20050>:
  collector->update_cardtable_mod_union = update_cardtable_mod_union;
  collector->get_cardtable_mod_union_for_object = major_get_cardtable_mod_union_for_object;
  <D.20051>:
  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.20052>; else goto <D.20053>;
  <D.20052>:
  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.20053>:
  if (0 != 0) goto <D.20054>; else goto <D.20055>;
  <D.20054>:
  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.20055>:
}


major_scan_vtype_concurrent (char * start, mword desc, struct SgenGrayQueue * queue)
{
  unsigned int D.20056;
  unsigned int D.20057;
  unsigned int D.20060;
  unsigned int D.20061;
  unsigned int D.20062;
  unsigned int D.20063;
  unsigned int D.20064;
  int D.20068;
  void * D.20074;
  struct FILE * gc_debug_file.9;
  int iftmp.10;
  int D.20079;
  int D.20081;
  _Bool D.20083;
  long int D.20084;
  long int D.20085;
  int iftmp.11;
  int D.20091;
  int D.20093;
  _Bool D.20095;
  long int D.20096;
  long int D.20097;
  int D.20103;
  int iftmp.12;
  int D.20112;
  int D.20114;
  _Bool D.20116;
  long int D.20117;
  long int D.20118;
  int iftmp.13;
  int D.20124;
  int D.20126;
  _Bool D.20128;
  long int D.20129;
  long int D.20130;
  unsigned int _index.14;
  unsigned int D.20134;
  int D.20135;
  int D.20139;
  void * D.20145;
  int iftmp.15;
  int D.20149;
  int D.20151;
  _Bool D.20153;
  long int D.20154;
  long int D.20155;
  int iftmp.16;
  int D.20161;
  int D.20163;
  _Bool D.20165;
  long int D.20166;
  long int D.20167;
  unsigned int _index.17;
  unsigned int D.20171;
  int D.20172;
  int D.20176;
  int iftmp.18;
  int D.20185;
  int D.20187;
  _Bool D.20189;
  long int D.20190;
  long int D.20191;
  int iftmp.19;
  int D.20197;
  int D.20199;
  _Bool D.20201;
  long int D.20202;
  long int D.20203;
  unsigned int D.20206;
  unsigned int D.20209;
  int D.20210;
  int desc.20;
  unsigned int D.20214;
  unsigned int el_size.21;
  unsigned int D.20216;
  int D.20220;
  void * D.20226;
  int iftmp.22;
  int D.20230;
  int D.20232;
  _Bool D.20234;
  long int D.20235;
  long int D.20236;
  int iftmp.23;
  int D.20242;
  int D.20244;
  _Bool D.20246;
  long int D.20247;
  long int D.20248;
  int D.20254;
  unsigned int offset.24;
  unsigned int D.20256;
  unsigned int i.25;
  unsigned int D.20258;
  void * * D.20259;
  int D.20263;
  void * D.20269;
  int iftmp.26;
  int D.20273;
  void * D.20275;
  int D.20276;
  _Bool D.20278;
  long int D.20279;
  long int D.20280;
  void * D.20283;
  int iftmp.27;
  int D.20287;
  int D.20289;
  _Bool D.20291;
  long int D.20292;
  long int D.20293;
  sizetype el_size.28;
  unsigned int D.20300;
  int D.20306;
  void * D.20312;
  int iftmp.29;
  int D.20316;
  int D.20318;
  _Bool D.20320;
  long int D.20321;
  long int D.20322;
  int iftmp.30;
  int D.20328;
  int D.20330;
  _Bool D.20332;
  long int D.20333;
  long int D.20334;
  unsigned int D.20337;
  int D.20343;
  void * D.20349;
  int iftmp.31;
  int D.20353;
  int D.20355;
  _Bool D.20357;
  long int D.20358;
  long int D.20359;
  int iftmp.32;
  int D.20365;
  int D.20367;
  _Bool D.20369;
  long int D.20370;
  long int D.20371;
  unsigned int D.20374;
  unsigned int D.20375;
  struct MonoVTable * D.20378;
  struct MonoClass * D.20379;
  const char * D.20380;
  const char * D.20381;
  gsize * bitmap_data.33;
  unsigned int D.20383;
  int D.20389;
  void * D.20395;
  int iftmp.34;
  int D.20399;
  int D.20401;
  _Bool D.20403;
  long int D.20404;
  long int D.20405;
  int iftmp.35;
  int D.20411;
  int D.20413;
  _Bool D.20415;
  long int D.20416;
  long int D.20417;
  int bwords.36;

  start = start + 4294967288;
  D.20056 = desc & 7;
  switch (D.20056) <default: <D.19651>, case 1: <D.19568>, case 2: <D.19579>, case 3: <D.19635>, case 4: <D.19591>, case 5: <D.19627>, case 7: <D.19650>>
  <D.19568>:
  D.20057 = desc & 4294901760;
  if (D.20057 != 0) goto <D.20058>; else goto <D.20059>;
  <D.20058>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.20060 = desc >> 16;
    D.20061 = D.20060 & 255;
    D.20062 = D.20061 * 4;
    _objptr = _objptr + D.20062;
    D.20063 = desc >> 24;
    D.20064 = D.20063 * 4;
    _objptr_end = _objptr + D.20064;
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.20067>; else goto <D.20065>;
      <D.20067>:
      D.20068 = sgen_ptr_in_nursery (__old);
      if (D.20068 == 0) goto <D.20069>; else goto <D.20065>;
      <D.20069>:
      __builtin_prefetch (__old);
      major_copy_or_mark_object_concurrent (_objptr, __old, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.20070>; else goto <D.20071>;
      <D.20070>:
      if (__old != __copy) goto <D.20072>; else goto <D.20073>;
      <D.20072>:
      D.20074 = *_objptr;
      gc_debug_file.9 = gc_debug_file;
      fprintf (gc_debug_file.9, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20074, __old);
      gc_debug_file.9 = gc_debug_file;
      fflush (gc_debug_file.9);
      <D.20073>:
      <D.20071>:
      D.20079 = sgen_ptr_in_nursery (__copy);
      if (D.20079 != 0) goto <D.20080>; else goto <D.20077>;
      <D.20080>:
      D.20081 = sgen_ptr_in_nursery (_objptr);
      if (D.20081 == 0) goto <D.20082>; else goto <D.20077>;
      <D.20082>:
      iftmp.10 = 1;
      goto <D.20078>;
      <D.20077>:
      iftmp.10 = 0;
      <D.20078>:
      D.20083 = iftmp.10 != 0;
      D.20084 = (long int) D.20083;
      D.20085 = __builtin_expect (D.20084, 0);
      if (D.20085 != 0) goto <D.20086>; else goto <D.20087>;
      <D.20086>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.20087>:
      goto <D.20066>;
      <D.20065>:
      D.20091 = sgen_ptr_in_nursery (__old);
      if (D.20091 != 0) goto <D.20092>; else goto <D.20089>;
      <D.20092>:
      D.20093 = sgen_ptr_in_nursery (_objptr);
      if (D.20093 == 0) goto <D.20094>; else goto <D.20089>;
      <D.20094>:
      iftmp.11 = 1;
      goto <D.20090>;
      <D.20089>:
      iftmp.11 = 0;
      <D.20090>:
      D.20095 = iftmp.11 != 0;
      D.20096 = (long int) D.20095;
      D.20097 = __builtin_expect (D.20096, 0);
      if (D.20097 != 0) goto <D.20098>; else goto <D.20099>;
      <D.20098>:
      sgen_add_to_global_remset (_objptr, __old);
      <D.20099>:
      <D.20066>:
    }
    _objptr = _objptr + 4;
    goto <D.19576>;
    <D.19575>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.20102>; else goto <D.20100>;
      <D.20102>:
      D.20103 = sgen_ptr_in_nursery (__old);
      if (D.20103 == 0) goto <D.20104>; else goto <D.20100>;
      <D.20104>:
      __builtin_prefetch (__old);
      major_copy_or_mark_object_concurrent (_objptr, __old, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.20105>; else goto <D.20106>;
      <D.20105>:
      if (__old != __copy) goto <D.20107>; else goto <D.20108>;
      <D.20107>:
      D.20074 = *_objptr;
      gc_debug_file.9 = gc_debug_file;
      fprintf (gc_debug_file.9, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20074, __old);
      gc_debug_file.9 = gc_debug_file;
      fflush (gc_debug_file.9);
      <D.20108>:
      <D.20106>:
      D.20112 = sgen_ptr_in_nursery (__copy);
      if (D.20112 != 0) goto <D.20113>; else goto <D.20110>;
      <D.20113>:
      D.20114 = sgen_ptr_in_nursery (_objptr);
      if (D.20114 == 0) goto <D.20115>; else goto <D.20110>;
      <D.20115>:
      iftmp.12 = 1;
      goto <D.20111>;
      <D.20110>:
      iftmp.12 = 0;
      <D.20111>:
      D.20116 = iftmp.12 != 0;
      D.20117 = (long int) D.20116;
      D.20118 = __builtin_expect (D.20117, 0);
      if (D.20118 != 0) goto <D.20119>; else goto <D.20120>;
      <D.20119>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.20120>:
      goto <D.20101>;
      <D.20100>:
      D.20124 = sgen_ptr_in_nursery (__old);
      if (D.20124 != 0) goto <D.20125>; else goto <D.20122>;
      <D.20125>:
      D.20126 = sgen_ptr_in_nursery (_objptr);
      if (D.20126 == 0) goto <D.20127>; else goto <D.20122>;
      <D.20127>:
      iftmp.13 = 1;
      goto <D.20123>;
      <D.20122>:
      iftmp.13 = 0;
      <D.20123>:
      D.20128 = iftmp.13 != 0;
      D.20129 = (long int) D.20128;
      D.20130 = __builtin_expect (D.20129, 0);
      if (D.20130 != 0) goto <D.20131>; else goto <D.20132>;
      <D.20131>:
      sgen_add_to_global_remset (_objptr, __old);
      <D.20132>:
      <D.20101>:
    }
    _objptr = _objptr + 4;
    <D.19576>:
    if (_objptr < _objptr_end) goto <D.19575>; else goto <D.19577>;
    <D.19577>:
  }
  <D.20059>:
  goto <D.19578>;
  <D.19579>:
  {
    void * * _objptr;
    gsize _bmap;

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

      _index = __builtin_ctz (_bmap);
      _index.14 = (unsigned int) _index;
      D.20134 = _index.14 * 4;
      _objptr = _objptr + D.20134;
      D.20135 = _index + 1;
      _bmap = _bmap >> D.20135;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.20138>; else goto <D.20136>;
        <D.20138>:
        D.20139 = sgen_ptr_in_nursery (__old);
        if (D.20139 == 0) goto <D.20140>; else goto <D.20136>;
        <D.20140>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.20141>; else goto <D.20142>;
        <D.20141>:
        if (__old != __copy) goto <D.20143>; else goto <D.20144>;
        <D.20143>:
        D.20145 = *_objptr;
        gc_debug_file.9 = gc_debug_file;
        fprintf (gc_debug_file.9, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20145, __old);
        gc_debug_file.9 = gc_debug_file;
        fflush (gc_debug_file.9);
        <D.20144>:
        <D.20142>:
        D.20149 = sgen_ptr_in_nursery (__copy);
        if (D.20149 != 0) goto <D.20150>; else goto <D.20147>;
        <D.20150>:
        D.20151 = sgen_ptr_in_nursery (_objptr);
        if (D.20151 == 0) goto <D.20152>; else goto <D.20147>;
        <D.20152>:
        iftmp.15 = 1;
        goto <D.20148>;
        <D.20147>:
        iftmp.15 = 0;
        <D.20148>:
        D.20153 = iftmp.15 != 0;
        D.20154 = (long int) D.20153;
        D.20155 = __builtin_expect (D.20154, 0);
        if (D.20155 != 0) goto <D.20156>; else goto <D.20157>;
        <D.20156>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20157>:
        goto <D.20137>;
        <D.20136>:
        D.20161 = sgen_ptr_in_nursery (__old);
        if (D.20161 != 0) goto <D.20162>; else goto <D.20159>;
        <D.20162>:
        D.20163 = sgen_ptr_in_nursery (_objptr);
        if (D.20163 == 0) goto <D.20164>; else goto <D.20159>;
        <D.20164>:
        iftmp.16 = 1;
        goto <D.20160>;
        <D.20159>:
        iftmp.16 = 0;
        <D.20160>:
        D.20165 = iftmp.16 != 0;
        D.20166 = (long int) D.20165;
        D.20167 = __builtin_expect (D.20166, 0);
        if (D.20167 != 0) goto <D.20168>; else goto <D.20169>;
        <D.20168>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.20169>:
        <D.20137>:
      }
      _objptr = _objptr + 4;
    }
    goto <D.19589>;
    <D.19588>:
    {
      int _index;

      _index = __builtin_ctz (_bmap);
      _index.17 = (unsigned int) _index;
      D.20171 = _index.17 * 4;
      _objptr = _objptr + D.20171;
      D.20172 = _index + 1;
      _bmap = _bmap >> D.20172;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.20175>; else goto <D.20173>;
        <D.20175>:
        D.20176 = sgen_ptr_in_nursery (__old);
        if (D.20176 == 0) goto <D.20177>; else goto <D.20173>;
        <D.20177>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.20178>; else goto <D.20179>;
        <D.20178>:
        if (__old != __copy) goto <D.20180>; else goto <D.20181>;
        <D.20180>:
        D.20145 = *_objptr;
        gc_debug_file.9 = gc_debug_file;
        fprintf (gc_debug_file.9, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20145, __old);
        gc_debug_file.9 = gc_debug_file;
        fflush (gc_debug_file.9);
        <D.20181>:
        <D.20179>:
        D.20185 = sgen_ptr_in_nursery (__copy);
        if (D.20185 != 0) goto <D.20186>; else goto <D.20183>;
        <D.20186>:
        D.20187 = sgen_ptr_in_nursery (_objptr);
        if (D.20187 == 0) goto <D.20188>; else goto <D.20183>;
        <D.20188>:
        iftmp.18 = 1;
        goto <D.20184>;
        <D.20183>:
        iftmp.18 = 0;
        <D.20184>:
        D.20189 = iftmp.18 != 0;
        D.20190 = (long int) D.20189;
        D.20191 = __builtin_expect (D.20190, 0);
        if (D.20191 != 0) goto <D.20192>; else goto <D.20193>;
        <D.20192>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20193>:
        goto <D.20174>;
        <D.20173>:
        D.20197 = sgen_ptr_in_nursery (__old);
        if (D.20197 != 0) goto <D.20198>; else goto <D.20195>;
        <D.20198>:
        D.20199 = sgen_ptr_in_nursery (_objptr);
        if (D.20199 == 0) goto <D.20200>; else goto <D.20195>;
        <D.20200>:
        iftmp.19 = 1;
        goto <D.20196>;
        <D.20195>:
        iftmp.19 = 0;
        <D.20196>:
        D.20201 = iftmp.19 != 0;
        D.20202 = (long int) D.20201;
        D.20203 = __builtin_expect (D.20202, 0);
        if (D.20203 != 0) goto <D.20204>; else goto <D.20205>;
        <D.20204>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.20205>:
        <D.20174>:
      }
      _objptr = _objptr + 4;
    }
    <D.19589>:
    if (_bmap != 0) goto <D.19588>; else goto <D.19590>;
    <D.19590>:
  }
  goto <D.19578>;
  <D.19591>:
  D.20206 = desc & 4294950912;
  if (D.20206 != 0) goto <D.20207>; else goto <D.20208>;
  <D.20207>:
  {
    int el_size;
    int etype;

    D.20209 = desc >> 3;
    D.20210 = (int) D.20209;
    el_size = D.20210 & 1023;
    desc.20 = (int) desc;
    etype = desc.20 & 49152;
    if (etype == 16384) goto <D.20212>; else goto <D.20213>;
    <D.20212>:
    {
      void * * p;
      void * * end_refs;

      p = start + 16;
      D.20214 = MEM[(struct MonoArray *)start].max_length;
      el_size.21 = (unsigned int) el_size;
      D.20216 = D.20214 * el_size.21;
      end_refs = p + D.20216;
      goto <D.19599>;
      <D.19598>:
      {
        void * __old;
        void * __copy;

        __old = *p;
        if (__old != 0B) goto <D.20219>; else goto <D.20217>;
        <D.20219>:
        D.20220 = sgen_ptr_in_nursery (__old);
        if (D.20220 == 0) goto <D.20221>; else goto <D.20217>;
        <D.20221>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (p, __old, queue);
        __copy = *p;
        if (0 != 0) goto <D.20222>; else goto <D.20223>;
        <D.20222>:
        if (__old != __copy) goto <D.20224>; else goto <D.20225>;
        <D.20224>:
        D.20226 = *p;
        gc_debug_file.9 = gc_debug_file;
        fprintf (gc_debug_file.9, "Overwrote field at %p with %p (was: %p)\n", p, D.20226, __old);
        gc_debug_file.9 = gc_debug_file;
        fflush (gc_debug_file.9);
        <D.20225>:
        <D.20223>:
        D.20230 = sgen_ptr_in_nursery (__copy);
        if (D.20230 != 0) goto <D.20231>; else goto <D.20228>;
        <D.20231>:
        D.20232 = sgen_ptr_in_nursery (p);
        if (D.20232 == 0) goto <D.20233>; else goto <D.20228>;
        <D.20233>:
        iftmp.22 = 1;
        goto <D.20229>;
        <D.20228>:
        iftmp.22 = 0;
        <D.20229>:
        D.20234 = iftmp.22 != 0;
        D.20235 = (long int) D.20234;
        D.20236 = __builtin_expect (D.20235, 0);
        if (D.20236 != 0) goto <D.20237>; else goto <D.20238>;
        <D.20237>:
        sgen_add_to_global_remset (p, __copy);
        <D.20238>:
        goto <D.20218>;
        <D.20217>:
        D.20242 = sgen_ptr_in_nursery (__old);
        if (D.20242 != 0) goto <D.20243>; else goto <D.20240>;
        <D.20243>:
        D.20244 = sgen_ptr_in_nursery (p);
        if (D.20244 == 0) goto <D.20245>; else goto <D.20240>;
        <D.20245>:
        iftmp.23 = 1;
        goto <D.20241>;
        <D.20240>:
        iftmp.23 = 0;
        <D.20241>:
        D.20246 = iftmp.23 != 0;
        D.20247 = (long int) D.20246;
        D.20248 = __builtin_expect (D.20247, 0);
        if (D.20248 != 0) goto <D.20249>; else goto <D.20250>;
        <D.20249>:
        sgen_add_to_global_remset (p, __old);
        <D.20250>:
        <D.20218>:
      }
      p = p + 4;
      <D.19599>:
      if (p < end_refs) goto <D.19598>; else goto <D.19600>;
      <D.19600>:
    }
    goto <D.20251>;
    <D.20213>:
    if (etype == 32768) goto <D.20252>; else goto <D.20253>;
    <D.20252>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.20060 = desc >> 16;
      D.20254 = (int) D.20060;
      offset = D.20254 & 255;
      D.20063 = desc >> 24;
      num_refs = (int) D.20063;
      e_start = start + 16;
      D.20214 = MEM[(struct MonoArray *)start].max_length;
      el_size.21 = (unsigned int) el_size;
      D.20216 = D.20214 * el_size.21;
      e_end = e_start + D.20216;
      goto <D.19613>;
      <D.19612>:
      {
        void * * p;
        int i;

        p = e_start;
        offset.24 = (unsigned int) offset;
        D.20256 = offset.24 * 4;
        p = p + D.20256;
        i = 0;
        goto <D.19610>;
        <D.19609>:
        {
          void * __old;
          void * __copy;

          i.25 = (unsigned int) i;
          D.20258 = i.25 * 4;
          D.20259 = p + D.20258;
          __old = *D.20259;
          if (__old != 0B) goto <D.20262>; else goto <D.20260>;
          <D.20262>:
          D.20263 = sgen_ptr_in_nursery (__old);
          if (D.20263 == 0) goto <D.20264>; else goto <D.20260>;
          <D.20264>:
          __builtin_prefetch (__old);
          i.25 = (unsigned int) i;
          D.20258 = i.25 * 4;
          D.20259 = p + D.20258;
          major_copy_or_mark_object_concurrent (D.20259, __old, queue);
          i.25 = (unsigned int) i;
          D.20258 = i.25 * 4;
          D.20259 = p + D.20258;
          __copy = *D.20259;
          if (0 != 0) goto <D.20265>; else goto <D.20266>;
          <D.20265>:
          if (__old != __copy) goto <D.20267>; else goto <D.20268>;
          <D.20267>:
          i.25 = (unsigned int) i;
          D.20258 = i.25 * 4;
          D.20259 = p + D.20258;
          D.20269 = *D.20259;
          i.25 = (unsigned int) i;
          D.20258 = i.25 * 4;
          D.20259 = p + D.20258;
          gc_debug_file.9 = gc_debug_file;
          fprintf (gc_debug_file.9, "Overwrote field at %p with %p (was: %p)\n", D.20259, D.20269, __old);
          gc_debug_file.9 = gc_debug_file;
          fflush (gc_debug_file.9);
          <D.20268>:
          <D.20266>:
          D.20273 = sgen_ptr_in_nursery (__copy);
          if (D.20273 != 0) goto <D.20274>; else goto <D.20271>;
          <D.20274>:
          i.25 = (unsigned int) i;
          D.20258 = i.25 * 4;
          D.20275 = p + D.20258;
          D.20276 = sgen_ptr_in_nursery (D.20275);
          if (D.20276 == 0) goto <D.20277>; else goto <D.20271>;
          <D.20277>:
          iftmp.26 = 1;
          goto <D.20272>;
          <D.20271>:
          iftmp.26 = 0;
          <D.20272>:
          D.20278 = iftmp.26 != 0;
          D.20279 = (long int) D.20278;
          D.20280 = __builtin_expect (D.20279, 0);
          if (D.20280 != 0) goto <D.20281>; else goto <D.20282>;
          <D.20281>:
          i.25 = (unsigned int) i;
          D.20258 = i.25 * 4;
          D.20283 = p + D.20258;
          sgen_add_to_global_remset (D.20283, __copy);
          <D.20282>:
          goto <D.20261>;
          <D.20260>:
          D.20287 = sgen_ptr_in_nursery (__old);
          if (D.20287 != 0) goto <D.20288>; else goto <D.20285>;
          <D.20288>:
          i.25 = (unsigned int) i;
          D.20258 = i.25 * 4;
          D.20275 = p + D.20258;
          D.20289 = sgen_ptr_in_nursery (D.20275);
          if (D.20289 == 0) goto <D.20290>; else goto <D.20285>;
          <D.20290>:
          iftmp.27 = 1;
          goto <D.20286>;
          <D.20285>:
          iftmp.27 = 0;
          <D.20286>:
          D.20291 = iftmp.27 != 0;
          D.20292 = (long int) D.20291;
          D.20293 = __builtin_expect (D.20292, 0);
          if (D.20293 != 0) goto <D.20294>; else goto <D.20295>;
          <D.20294>:
          i.25 = (unsigned int) i;
          D.20258 = i.25 * 4;
          D.20283 = p + D.20258;
          sgen_add_to_global_remset (D.20283, __old);
          <D.20295>:
          <D.20261>:
        }
        i = i + 1;
        <D.19610>:
        if (i < num_refs) goto <D.19609>; else goto <D.19611>;
        <D.19611>:
        el_size.28 = (sizetype) el_size;
        e_start = e_start + el_size.28;
      }
      <D.19613>:
      if (e_start < e_end) goto <D.19612>; else goto <D.19614>;
      <D.19614>:
    }
    goto <D.20297>;
    <D.20253>:
    if (etype == 49152) goto <D.20298>; else goto <D.20299>;
    <D.20298>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 16;
      D.20214 = MEM[(struct MonoArray *)start].max_length;
      el_size.21 = (unsigned int) el_size;
      D.20216 = D.20214 * el_size.21;
      e_end = e_start + D.20216;
      goto <D.19625>;
      <D.19624>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.19622>;
        <D.19621>:
        D.20300 = _bmap & 1;
        if (D.20300 != 0) goto <D.20301>; else goto <D.20302>;
        <D.20301>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.20305>; else goto <D.20303>;
          <D.20305>:
          D.20306 = sgen_ptr_in_nursery (__old);
          if (D.20306 == 0) goto <D.20307>; else goto <D.20303>;
          <D.20307>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object_concurrent (p, __old, queue);
          __copy = *p;
          if (0 != 0) goto <D.20308>; else goto <D.20309>;
          <D.20308>:
          if (__old != __copy) goto <D.20310>; else goto <D.20311>;
          <D.20310>:
          D.20312 = *p;
          gc_debug_file.9 = gc_debug_file;
          fprintf (gc_debug_file.9, "Overwrote field at %p with %p (was: %p)\n", p, D.20312, __old);
          gc_debug_file.9 = gc_debug_file;
          fflush (gc_debug_file.9);
          <D.20311>:
          <D.20309>:
          D.20316 = sgen_ptr_in_nursery (__copy);
          if (D.20316 != 0) goto <D.20317>; else goto <D.20314>;
          <D.20317>:
          D.20318 = sgen_ptr_in_nursery (p);
          if (D.20318 == 0) goto <D.20319>; else goto <D.20314>;
          <D.20319>:
          iftmp.29 = 1;
          goto <D.20315>;
          <D.20314>:
          iftmp.29 = 0;
          <D.20315>:
          D.20320 = iftmp.29 != 0;
          D.20321 = (long int) D.20320;
          D.20322 = __builtin_expect (D.20321, 0);
          if (D.20322 != 0) goto <D.20323>; else goto <D.20324>;
          <D.20323>:
          sgen_add_to_global_remset (p, __copy);
          <D.20324>:
          goto <D.20304>;
          <D.20303>:
          D.20328 = sgen_ptr_in_nursery (__old);
          if (D.20328 != 0) goto <D.20329>; else goto <D.20326>;
          <D.20329>:
          D.20330 = sgen_ptr_in_nursery (p);
          if (D.20330 == 0) goto <D.20331>; else goto <D.20326>;
          <D.20331>:
          iftmp.30 = 1;
          goto <D.20327>;
          <D.20326>:
          iftmp.30 = 0;
          <D.20327>:
          D.20332 = iftmp.30 != 0;
          D.20333 = (long int) D.20332;
          D.20334 = __builtin_expect (D.20333, 0);
          if (D.20334 != 0) goto <D.20335>; else goto <D.20336>;
          <D.20335>:
          sgen_add_to_global_remset (p, __old);
          <D.20336>:
          <D.20304>:
        }
        <D.20302>:
        _bmap = _bmap >> 1;
        p = p + 4;
        <D.19622>:
        if (_bmap != 0) goto <D.19621>; else goto <D.19623>;
        <D.19623>:
        el_size.28 = (sizetype) el_size;
        e_start = e_start + el_size.28;
      }
      <D.19625>:
      if (e_start < e_end) goto <D.19624>; else goto <D.19626>;
      <D.19626>:
    }
    <D.20299>:
    <D.20297>:
    <D.20251>:
  }
  <D.20208>:
  goto <D.19578>;
  <D.19627>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 3;
    _objptr = _objptr + 8;
    goto <D.19633>;
    <D.19632>:
    D.20337 = _bmap & 1;
    if (D.20337 != 0) goto <D.20338>; else goto <D.20339>;
    <D.20338>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.20342>; else goto <D.20340>;
      <D.20342>:
      D.20343 = sgen_ptr_in_nursery (__old);
      if (D.20343 == 0) goto <D.20344>; else goto <D.20340>;
      <D.20344>:
      __builtin_prefetch (__old);
      major_copy_or_mark_object_concurrent (_objptr, __old, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.20345>; else goto <D.20346>;
      <D.20345>:
      if (__old != __copy) goto <D.20347>; else goto <D.20348>;
      <D.20347>:
      D.20349 = *_objptr;
      gc_debug_file.9 = gc_debug_file;
      fprintf (gc_debug_file.9, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20349, __old);
      gc_debug_file.9 = gc_debug_file;
      fflush (gc_debug_file.9);
      <D.20348>:
      <D.20346>:
      D.20353 = sgen_ptr_in_nursery (__copy);
      if (D.20353 != 0) goto <D.20354>; else goto <D.20351>;
      <D.20354>:
      D.20355 = sgen_ptr_in_nursery (_objptr);
      if (D.20355 == 0) goto <D.20356>; else goto <D.20351>;
      <D.20356>:
      iftmp.31 = 1;
      goto <D.20352>;
      <D.20351>:
      iftmp.31 = 0;
      <D.20352>:
      D.20357 = iftmp.31 != 0;
      D.20358 = (long int) D.20357;
      D.20359 = __builtin_expect (D.20358, 0);
      if (D.20359 != 0) goto <D.20360>; else goto <D.20361>;
      <D.20360>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.20361>:
      goto <D.20341>;
      <D.20340>:
      D.20365 = sgen_ptr_in_nursery (__old);
      if (D.20365 != 0) goto <D.20366>; else goto <D.20363>;
      <D.20366>:
      D.20367 = sgen_ptr_in_nursery (_objptr);
      if (D.20367 == 0) goto <D.20368>; else goto <D.20363>;
      <D.20368>:
      iftmp.32 = 1;
      goto <D.20364>;
      <D.20363>:
      iftmp.32 = 0;
      <D.20364>:
      D.20369 = iftmp.32 != 0;
      D.20370 = (long int) D.20369;
      D.20371 = __builtin_expect (D.20370, 0);
      if (D.20371 != 0) goto <D.20372>; else goto <D.20373>;
      <D.20372>:
      sgen_add_to_global_remset (_objptr, __old);
      <D.20373>:
      <D.20341>:
    }
    <D.20339>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 4;
    <D.19633>:
    if (_bmap != 0) goto <D.19632>; else goto <D.19634>;
    <D.19634>:
  }
  goto <D.19578>;
  <D.19635>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.20374 = *bitmap_data;
    D.20375 = D.20374 + 4294967295;
    bwords = (int) D.20375;
    start_run = _objptr;
    bitmap_data = bitmap_data + 4;
    if (0 != 0) goto <D.20376>; else goto <D.20377>;
    <D.20376>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.20378 = myobj->vtable;
      D.20379 = D.20378->klass;
      D.20380 = D.20379->name;
      D.20378 = myobj->vtable;
      D.20379 = D.20378->klass;
      D.20381 = D.20379->name_space;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.20381, D.20380);
    }
    <D.20377>:
    goto <D.19648>;
    <D.19647>:
    {
      gsize _bmap;

      bitmap_data.33 = bitmap_data;
      bitmap_data = bitmap_data.33 + 4;
      _bmap = *bitmap_data.33;
      _objptr = start_run;
      goto <D.19645>;
      <D.19644>:
      D.20383 = _bmap & 1;
      if (D.20383 != 0) goto <D.20384>; else goto <D.20385>;
      <D.20384>:
      {
        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.20395 = *_objptr;
        gc_debug_file.9 = gc_debug_file;
        fprintf (gc_debug_file.9, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20395, __old);
        gc_debug_file.9 = gc_debug_file;
        fflush (gc_debug_file.9);
        <D.20394>:
        <D.20392>:
        D.20399 = sgen_ptr_in_nursery (__copy);
        if (D.20399 != 0) goto <D.20400>; else goto <D.20397>;
        <D.20400>:
        D.20401 = sgen_ptr_in_nursery (_objptr);
        if (D.20401 == 0) goto <D.20402>; else goto <D.20397>;
        <D.20402>:
        iftmp.34 = 1;
        goto <D.20398>;
        <D.20397>:
        iftmp.34 = 0;
        <D.20398>:
        D.20403 = iftmp.34 != 0;
        D.20404 = (long int) D.20403;
        D.20405 = __builtin_expect (D.20404, 0);
        if (D.20405 != 0) goto <D.20406>; else goto <D.20407>;
        <D.20406>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20407>:
        goto <D.20387>;
        <D.20386>:
        D.20411 = sgen_ptr_in_nursery (__old);
        if (D.20411 != 0) goto <D.20412>; else goto <D.20409>;
        <D.20412>:
        D.20413 = sgen_ptr_in_nursery (_objptr);
        if (D.20413 == 0) goto <D.20414>; else goto <D.20409>;
        <D.20414>:
        iftmp.35 = 1;
        goto <D.20410>;
        <D.20409>:
        iftmp.35 = 0;
        <D.20410>:
        D.20415 = iftmp.35 != 0;
        D.20416 = (long int) D.20415;
        D.20417 = __builtin_expect (D.20416, 0);
        if (D.20417 != 0) goto <D.20418>; else goto <D.20419>;
        <D.20418>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.20419>:
        <D.20387>:
      }
      <D.20385>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.19645>:
      if (_bmap != 0) goto <D.19644>; else goto <D.19646>;
      <D.19646>:
      start_run = start_run + 128;
    }
    <D.19648>:
    bwords.36 = bwords;
    bwords = bwords.36 + -1;
    if (bwords.36 > 0) goto <D.19647>; else goto <D.19649>;
    <D.19649>:
  }
  goto <D.19578>;
  <D.19650>:
  goto <D.19578>;
  <D.19651>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.19578>:
}


major_copy_or_mark_object_concurrent (void * * ptr, void * obj, struct SgenGrayQueue * queue)
{
  int iftmp.37;
  unsigned int D.20425;
  unsigned int D.20426;
  unsigned int D.20428;
  _Bool D.20430;
  long int D.20431;
  long int D.20432;
  int D.20435;
  unsigned int D.20438;
  unsigned int D.20439;
  unsigned int obj.38;
  unsigned int D.20443;
  struct MSBlockHeader * D.20444;
  int obj.39;
  int obj.40;
  int D.20447;
  int D.20448;
  unsigned int D.20454;
  long int D.20455;
  long unsigned int D.20456;
  long unsigned int D.20457;
  long unsigned int D.20460;
  unsigned char D.20461;
  unsigned char D.20462;
  int iftmp.41;
  struct GrayQueueSection * D.20469;
  int D.20471;
  _Bool D.20472;
  long int D.20473;
  long int D.20474;
  int D.20478;
  int D.20479;
  int D.20481;
  struct MonoVTable * D.20484;
  void * D.20485;
  unsigned int D.20486;
  int D.20487;
  int iftmp.42;
  _Bool D.20495;
  long int D.20496;
  long int D.20497;
  int D.20501;
  int D.20502;

  D.20425 = MEM[(mword *)obj];
  D.20426 = D.20425 & 1;
  if (D.20426 != 0) goto <D.20427>; else goto <D.20423>;
  <D.20427>:
  D.20425 = MEM[(mword *)obj];
  D.20428 = D.20425 & 4294967292;
  if (D.20428 != 0) goto <D.20429>; else goto <D.20423>;
  <D.20429>:
  iftmp.37 = 1;
  goto <D.20424>;
  <D.20423>:
  iftmp.37 = 0;
  <D.20424>:
  D.20430 = iftmp.37 != 0;
  D.20431 = (long int) D.20430;
  D.20432 = __builtin_expect (D.20431, 0);
  if (D.20432 != 0) goto <D.20433>; else goto <D.20434>;
  <D.20433>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 1280, "!SGEN_OBJECT_IS_FORWARDED (obj)");
  <D.20434>:
  D.20435 = sgen_ptr_in_nursery (obj);
  if (D.20435 == 0) goto <D.20436>; else goto <D.20437>;
  <D.20436>:
  {
    mword objsize;

    D.20438 = sgen_safe_object_get_size (obj);
    D.20439 = D.20438 + 7;
    objsize = D.20439 & 4294967288;
    if (objsize <= 8000) goto <D.20440>; else goto <D.20441>;
    <D.20440>:
    {
      struct MSBlockInfo * block;

      obj.38 = (unsigned int) obj;
      D.20443 = obj.38 & 4294950912;
      D.20444 = (struct MSBlockHeader *) D.20443;
      block = D.20444->info;
      {
        int __word;
        int __bit;

        {
          int i;

          obj.39 = (int) obj;
          obj.40 = (int) obj;
          D.20447 = obj.40 & -16384;
          D.20448 = obj.39 - D.20447;
          i = D.20448 >> 3;
          if (1 != 0) goto <D.20449>; else goto <D.20450>;
          <D.20449>:
          __word = i >> 5;
          __bit = i & 31;
          goto <D.20451>;
          <D.20450>:
          __word = i >> 6;
          __bit = i & 63;
          <D.20451>:
        }
        if (0 != 0) goto <D.20452>; else goto <D.20453>;
        <D.20452>:
        monoeg_g_log (0B, 4, "object %p not allocated", obj);
        <D.19297>:
        goto <D.19297>;
        <D.20453>:
        D.20454 = block->mark_words[__word];
        D.20455 = 1 << __bit;
        D.20456 = (long unsigned int) D.20455;
        D.20457 = D.20454 & D.20456;
        if (D.20457 == 0) goto <D.20458>; else goto <D.20459>;
        <D.20458>:
        D.20454 = block->mark_words[__word];
        D.20455 = 1 << __bit;
        D.20456 = (long unsigned int) D.20455;
        D.20460 = D.20454 | D.20456;
        block->mark_words[__word] = D.20460;
        D.20461 = BIT_FIELD_REF <*block, 8, 96>;
        D.20462 = D.20461 & 2;
        if (D.20462 != 0) goto <D.20463>; else goto <D.20464>;
        <D.20463>:
        D.20469 = queue->first;
        if (D.20469 == 0B) goto <D.20466>; else goto <D.20470>;
        <D.20470>:
        D.20469 = queue->first;
        D.20471 = D.20469->end;
        if (D.20471 == 125) goto <D.20466>; else goto <D.20467>;
        <D.20466>:
        iftmp.41 = 1;
        goto <D.20468>;
        <D.20467>:
        iftmp.41 = 0;
        <D.20468>:
        D.20472 = iftmp.41 != 0;
        D.20473 = (long int) D.20472;
        D.20474 = __builtin_expect (D.20473, 0);
        if (D.20474 != 0) goto <D.20475>; else goto <D.20476>;
        <D.20475>:
        sgen_gray_object_enqueue (queue, obj);
        goto <D.20477>;
        <D.20476>:
        D.20469 = queue->first;
        D.20469 = queue->first;
        D.20471 = D.20469->end;
        D.20478 = D.20471;
        D.20479 = D.20478 + 1;
        D.20469->end = D.20479;
        D.20469->objects[D.20478] = obj;
        <D.20477>:
        __builtin_prefetch (obj);
        <D.20464>:
        <D.20459>:
      }
    }
    goto <D.20480>;
    <D.20441>:
    D.20481 = sgen_los_object_is_pinned (obj);
    if (D.20481 != 0) goto <D.20482>; else goto <D.20483>;
    <D.20482>:
    return;
    <D.20483>:
    sgen_los_pin_object (obj);
    D.20425 = MEM[(mword *)obj];
    D.20428 = D.20425 & 4294967292;
    D.20484 = (struct MonoVTable *) D.20428;
    D.20485 = D.20484->gc_descr;
    D.20486 = (unsigned int) D.20485;
    D.20487 = sgen_gc_descr_has_references (D.20486);
    if (D.20487 != 0) goto <D.20488>; else goto <D.20489>;
    <D.20488>:
    D.20469 = queue->first;
    if (D.20469 == 0B) goto <D.20491>; else goto <D.20494>;
    <D.20494>:
    D.20469 = queue->first;
    D.20471 = D.20469->end;
    if (D.20471 == 125) goto <D.20491>; else goto <D.20492>;
    <D.20491>:
    iftmp.42 = 1;
    goto <D.20493>;
    <D.20492>:
    iftmp.42 = 0;
    <D.20493>:
    D.20495 = iftmp.42 != 0;
    D.20496 = (long int) D.20495;
    D.20497 = __builtin_expect (D.20496, 0);
    if (D.20497 != 0) goto <D.20498>; else goto <D.20499>;
    <D.20498>:
    sgen_gray_object_enqueue (queue, obj);
    goto <D.20500>;
    <D.20499>:
    D.20469 = queue->first;
    D.20469 = queue->first;
    D.20471 = D.20469->end;
    D.20501 = D.20471;
    D.20502 = D.20501 + 1;
    D.20469->end = D.20502;
    D.20469->objects[D.20501] = obj;
    <D.20500>:
    __builtin_prefetch (obj);
    <D.20489>:
    <D.20480>:
  }
  <D.20437>:
}


sgen_safe_object_get_size (struct MonoObject * obj)
{
  char * iftmp.43;
  unsigned int D.20505;
  unsigned int D.20506;
  unsigned int D.20509;
  guint D.20513;
  struct MonoVTable * D.20514;
  char * forwarded;

  D.20505 = MEM[(mword *)obj];
  D.20506 = D.20505 & 1;
  if (D.20506 != 0) goto <D.20507>; else goto <D.20508>;
  <D.20507>:
  D.20505 = MEM[(mword *)obj];
  D.20509 = D.20505 & 4294967292;
  iftmp.43 = (char *) D.20509;
  goto <D.20510>;
  <D.20508>:
  iftmp.43 = 0B;
  <D.20510>:
  forwarded = iftmp.43;
  if (forwarded != 0B) goto <D.20511>; else goto <D.20512>;
  <D.20511>:
  obj = forwarded;
  <D.20512>:
  D.20505 = MEM[(mword *)obj];
  D.20509 = D.20505 & 4294967292;
  D.20514 = (struct MonoVTable *) D.20509;
  D.20513 = sgen_par_object_get_size (D.20514, obj);
  return D.20513;
}


sgen_par_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  void * D.20516;
  unsigned int D.20517;
  guint D.20522;
  int D.20523;
  int D.20524;
  unsigned int D.20525;
  unsigned int D.20528;
  int D.20529;
  unsigned int D.20530;
  unsigned int element_size.44;
  unsigned int D.20532;
  unsigned int D.20533;
  struct MonoClass * D.20536;
  unsigned char D.20537;
  unsigned int D.20538;
  unsigned int D.20539;
  mword descr;
  mword type;

  D.20516 = vtable->gc_descr;
  descr = (mword) D.20516;
  type = descr & 7;
  D.20517 = type + 4294967295;
  if (D.20517 <= 1) goto <D.20518>; else goto <D.20519>;
  <D.20518>:
  {
    mword size;

    size = descr & 65528;
    if (size == 0) goto <D.20520>; else goto <D.20521>;
    <D.20520>:
    D.20523 = MEM[(struct MonoString *)o].length;
    D.20524 = D.20523 * 2;
    D.20525 = (unsigned int) D.20524;
    D.20522 = D.20525 + 14;
    return D.20522;
    <D.20521>:
    D.20522 = size;
    return D.20522;
  }
  <D.20519>:
  if (type == 4) goto <D.20526>; else goto <D.20527>;
  <D.20526>:
  {
    int element_size;
    struct MonoArray * array;
    size_t size;

    D.20528 = descr >> 3;
    D.20529 = (int) D.20528;
    element_size = D.20529 & 1023;
    array = o;
    D.20530 = array->max_length;
    element_size.44 = (unsigned int) element_size;
    D.20532 = D.20530 * element_size.44;
    size = D.20532 + 16;
    D.20533 = descr & 8192;
    if (D.20533 != 0) goto <D.20534>; else goto <D.20535>;
    <D.20534>:
    size = size + 3;
    size = size & 4294967292;
    D.20536 = vtable->klass;
    D.20537 = D.20536->rank;
    D.20538 = (unsigned int) D.20537;
    D.20539 = D.20538 * 8;
    size = D.20539 + size;
    <D.20535>:
    D.20522 = size;
    return D.20522;
  }
  <D.20527>:
  D.20522 = slow_object_get_size (vtable, o);
  return D.20522;
}


slow_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  struct MonoClass * D.20541;
  guint D.20544;
  int D.20545;
  int D.20546;
  unsigned int D.20547;
  unsigned char D.20548;
  int D.20551;
  unsigned int D.20552;
  unsigned int D.20553;
  unsigned int D.20554;
  struct MonoArrayBounds * D.20555;
  _Bool D.20556;
  long int D.20557;
  long int D.20558;
  unsigned int D.20561;
  unsigned int D.20562;
  int D.20563;
  struct MonoClass * klass;

  klass = vtable->klass;
  D.20541 = mono_defaults.string_class;
  if (D.20541 == klass) goto <D.20542>; else goto <D.20543>;
  <D.20542>:
  D.20545 = MEM[(struct MonoString *)o].length;
  D.20546 = D.20545 * 2;
  D.20547 = (unsigned int) D.20546;
  D.20544 = D.20547 + 14;
  return D.20544;
  <D.20543>:
  D.20548 = klass->rank;
  if (D.20548 != 0) goto <D.20549>; else goto <D.20550>;
  <D.20549>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.20551 = klass->sizes.element_size;
    D.20552 = (unsigned int) D.20551;
    D.20553 = array->max_length;
    D.20554 = D.20552 * D.20553;
    size = D.20554 + 16;
    D.20555 = array->bounds;
    D.20556 = D.20555 != 0B;
    D.20557 = (long int) D.20556;
    D.20558 = __builtin_expect (D.20557, 0);
    if (D.20558 != 0) goto <D.20559>; else goto <D.20560>;
    <D.20559>:
    size = size + 3;
    size = size & 4294967292;
    D.20548 = klass->rank;
    D.20561 = (unsigned int) D.20548;
    D.20562 = D.20561 * 8;
    size = D.20562 + size;
    <D.20560>:
    D.20544 = size;
    return D.20544;
  }
  <D.20550>:
  D.20563 = klass->instance_size;
  D.20544 = (guint) D.20563;
  return D.20544;
}


sgen_gc_descr_has_references (mword desc)
{
  unsigned int D.20565;
  gboolean D.20568;
  unsigned int D.20569;
  unsigned int D.20572;

  D.20565 = desc & 4294901767;
  if (D.20565 == 1) goto <D.20566>; else goto <D.20567>;
  <D.20566>:
  D.20568 = 0;
  return D.20568;
  <D.20567>:
  D.20569 = desc & 49159;
  if (D.20569 == 4) goto <D.20570>; else goto <D.20571>;
  <D.20570>:
  D.20568 = 0;
  return D.20568;
  <D.20571>:
  D.20572 = desc & 7;
  if (D.20572 == 7) goto <D.20573>; else goto <D.20574>;
  <D.20573>:
  D.20568 = 0;
  return D.20568;
  <D.20574>:
  D.20568 = 1;
  return D.20568;
}


sgen_ptr_in_nursery (void * p)
{
  gboolean D.20576;
  int sgen_nursery_bits.45;
  int D.20578;
  int D.20579;
  unsigned int D.20580;
  unsigned int p.46;
  unsigned int D.20582;
  char * sgen_nursery_start.47;
  unsigned int sgen_nursery_start.48;
  _Bool D.20585;

  sgen_nursery_bits.45 = sgen_nursery_bits;
  D.20578 = 1 << sgen_nursery_bits.45;
  D.20579 = -D.20578;
  D.20580 = (unsigned int) D.20579;
  p.46 = (unsigned int) p;
  D.20582 = D.20580 & p.46;
  sgen_nursery_start.47 = sgen_nursery_start;
  sgen_nursery_start.48 = (unsigned int) sgen_nursery_start.47;
  D.20585 = D.20582 == sgen_nursery_start.48;
  D.20576 = (gboolean) D.20585;
  return D.20576;
}


major_scan_object_concurrent (char * start, struct SgenGrayQueue * queue)
{
  unsigned int D.20587;
  unsigned int D.20588;
  unsigned int D.20589;
  unsigned int D.20590;
  unsigned int D.20593;
  unsigned int D.20594;
  unsigned int D.20595;
  unsigned int D.20596;
  unsigned int D.20597;
  int D.20601;
  void * D.20607;
  struct FILE * gc_debug_file.49;
  int iftmp.50;
  int D.20612;
  int D.20614;
  _Bool D.20616;
  long int D.20617;
  long int D.20618;
  int iftmp.51;
  int D.20624;
  int D.20626;
  _Bool D.20628;
  long int D.20629;
  long int D.20630;
  int D.20636;
  int iftmp.52;
  int D.20645;
  int D.20647;
  _Bool D.20649;
  long int D.20650;
  long int D.20651;
  int iftmp.53;
  int D.20657;
  int D.20659;
  _Bool D.20661;
  long int D.20662;
  long int D.20663;
  unsigned int _index.54;
  unsigned int D.20667;
  int D.20668;
  int D.20672;
  void * D.20678;
  int iftmp.55;
  int D.20682;
  int D.20684;
  _Bool D.20686;
  long int D.20687;
  long int D.20688;
  int iftmp.56;
  int D.20694;
  int D.20696;
  _Bool D.20698;
  long int D.20699;
  long int D.20700;
  unsigned int _index.57;
  unsigned int D.20704;
  int D.20705;
  int D.20709;
  int iftmp.58;
  int D.20718;
  int D.20720;
  _Bool D.20722;
  long int D.20723;
  long int D.20724;
  int iftmp.59;
  int D.20730;
  int D.20732;
  _Bool D.20734;
  long int D.20735;
  long int D.20736;
  unsigned int D.20739;
  unsigned int D.20742;
  int D.20743;
  int desc.60;
  unsigned int D.20747;
  unsigned int el_size.61;
  unsigned int D.20749;
  int D.20753;
  void * D.20759;
  int iftmp.62;
  int D.20763;
  int D.20765;
  _Bool D.20767;
  long int D.20768;
  long int D.20769;
  int iftmp.63;
  int D.20775;
  int D.20777;
  _Bool D.20779;
  long int D.20780;
  long int D.20781;
  int D.20787;
  unsigned int offset.64;
  unsigned int D.20789;
  unsigned int i.65;
  unsigned int D.20791;
  void * * D.20792;
  int D.20796;
  void * D.20802;
  int iftmp.66;
  int D.20806;
  void * D.20808;
  int D.20809;
  _Bool D.20811;
  long int D.20812;
  long int D.20813;
  void * D.20816;
  int iftmp.67;
  int D.20820;
  int D.20822;
  _Bool D.20824;
  long int D.20825;
  long int D.20826;
  sizetype el_size.68;
  unsigned int D.20833;
  int D.20839;
  void * D.20845;
  int iftmp.69;
  int D.20849;
  int D.20851;
  _Bool D.20853;
  long int D.20854;
  long int D.20855;
  int iftmp.70;
  int D.20861;
  int D.20863;
  _Bool D.20865;
  long int D.20866;
  long int D.20867;
  unsigned int D.20870;
  int D.20876;
  void * D.20882;
  int iftmp.71;
  int D.20886;
  int D.20888;
  _Bool D.20890;
  long int D.20891;
  long int D.20892;
  int iftmp.72;
  int D.20898;
  int D.20900;
  _Bool D.20902;
  long int D.20903;
  long int D.20904;
  unsigned int D.20907;
  unsigned int D.20908;
  struct MonoVTable * D.20911;
  struct MonoClass * D.20912;
  const char * D.20913;
  const char * D.20914;
  gsize * bitmap_data.73;
  unsigned int D.20916;
  int D.20922;
  void * D.20928;
  int iftmp.74;
  int D.20932;
  int D.20934;
  _Bool D.20936;
  long int D.20937;
  long int D.20938;
  int iftmp.75;
  int D.20944;
  int D.20946;
  _Bool D.20948;
  long int D.20949;
  long int D.20950;
  int bwords.76;
  unsigned int D.20954;
  gsize * mbitmap_data.77;
  unsigned int D.20956;
  unsigned int D.20957;
  struct MonoClass * D.20958;
  unsigned int el_size.78;
  unsigned int D.20960;
  const char * D.20963;
  const char * D.20964;
  gsize * bitmap_data.79;
  unsigned int D.20966;
  int D.20972;
  void * D.20978;
  int iftmp.80;
  int D.20982;
  int D.20984;
  _Bool D.20986;
  long int D.20987;
  long int D.20988;
  int iftmp.81;
  int D.20994;
  int D.20996;
  _Bool D.20998;
  long int D.20999;
  long int D.21000;
  unsigned int bwords.82;
  sizetype el_size.83;

  {
    struct GCVTable * vt;
    mword desc;

    D.20587 = MEM[(mword *)start];
    D.20588 = D.20587 & 4294967292;
    vt = (struct GCVTable *) D.20588;
    desc = vt->desc;
    D.20589 = desc & 7;
    switch (D.20589) <default: <D.19562>, case 1: <D.19457>, case 2: <D.19468>, case 3: <D.19524>, case 4: <D.19480>, case 5: <D.19516>, case 6: <D.19539>, case 7: <D.19561>>
    <D.19457>:
    D.20590 = desc & 4294901760;
    if (D.20590 != 0) goto <D.20591>; else goto <D.20592>;
    <D.20591>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.20593 = desc >> 16;
      D.20594 = D.20593 & 255;
      D.20595 = D.20594 * 4;
      _objptr = _objptr + D.20595;
      D.20596 = desc >> 24;
      D.20597 = D.20596 * 4;
      _objptr_end = _objptr + D.20597;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.20600>; else goto <D.20598>;
        <D.20600>:
        D.20601 = sgen_ptr_in_nursery (__old);
        if (D.20601 == 0) goto <D.20602>; else goto <D.20598>;
        <D.20602>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.20603>; else goto <D.20604>;
        <D.20603>:
        if (__old != __copy) goto <D.20605>; else goto <D.20606>;
        <D.20605>:
        D.20607 = *_objptr;
        gc_debug_file.49 = gc_debug_file;
        fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20607, __old);
        gc_debug_file.49 = gc_debug_file;
        fflush (gc_debug_file.49);
        <D.20606>:
        <D.20604>:
        D.20612 = sgen_ptr_in_nursery (__copy);
        if (D.20612 != 0) goto <D.20613>; else goto <D.20610>;
        <D.20613>:
        D.20614 = sgen_ptr_in_nursery (_objptr);
        if (D.20614 == 0) goto <D.20615>; else goto <D.20610>;
        <D.20615>:
        iftmp.50 = 1;
        goto <D.20611>;
        <D.20610>:
        iftmp.50 = 0;
        <D.20611>:
        D.20616 = iftmp.50 != 0;
        D.20617 = (long int) D.20616;
        D.20618 = __builtin_expect (D.20617, 0);
        if (D.20618 != 0) goto <D.20619>; else goto <D.20620>;
        <D.20619>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20620>:
        goto <D.20599>;
        <D.20598>:
        D.20624 = sgen_ptr_in_nursery (__old);
        if (D.20624 != 0) goto <D.20625>; else goto <D.20622>;
        <D.20625>:
        D.20626 = sgen_ptr_in_nursery (_objptr);
        if (D.20626 == 0) goto <D.20627>; else goto <D.20622>;
        <D.20627>:
        iftmp.51 = 1;
        goto <D.20623>;
        <D.20622>:
        iftmp.51 = 0;
        <D.20623>:
        D.20628 = iftmp.51 != 0;
        D.20629 = (long int) D.20628;
        D.20630 = __builtin_expect (D.20629, 0);
        if (D.20630 != 0) goto <D.20631>; else goto <D.20632>;
        <D.20631>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.20632>:
        <D.20599>:
      }
      _objptr = _objptr + 4;
      goto <D.19465>;
      <D.19464>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.20635>; else goto <D.20633>;
        <D.20635>:
        D.20636 = sgen_ptr_in_nursery (__old);
        if (D.20636 == 0) goto <D.20637>; else goto <D.20633>;
        <D.20637>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.20638>; else goto <D.20639>;
        <D.20638>:
        if (__old != __copy) goto <D.20640>; else goto <D.20641>;
        <D.20640>:
        D.20607 = *_objptr;
        gc_debug_file.49 = gc_debug_file;
        fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20607, __old);
        gc_debug_file.49 = gc_debug_file;
        fflush (gc_debug_file.49);
        <D.20641>:
        <D.20639>:
        D.20645 = sgen_ptr_in_nursery (__copy);
        if (D.20645 != 0) goto <D.20646>; else goto <D.20643>;
        <D.20646>:
        D.20647 = sgen_ptr_in_nursery (_objptr);
        if (D.20647 == 0) goto <D.20648>; else goto <D.20643>;
        <D.20648>:
        iftmp.52 = 1;
        goto <D.20644>;
        <D.20643>:
        iftmp.52 = 0;
        <D.20644>:
        D.20649 = iftmp.52 != 0;
        D.20650 = (long int) D.20649;
        D.20651 = __builtin_expect (D.20650, 0);
        if (D.20651 != 0) goto <D.20652>; else goto <D.20653>;
        <D.20652>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20653>:
        goto <D.20634>;
        <D.20633>:
        D.20657 = sgen_ptr_in_nursery (__old);
        if (D.20657 != 0) goto <D.20658>; else goto <D.20655>;
        <D.20658>:
        D.20659 = sgen_ptr_in_nursery (_objptr);
        if (D.20659 == 0) goto <D.20660>; else goto <D.20655>;
        <D.20660>:
        iftmp.53 = 1;
        goto <D.20656>;
        <D.20655>:
        iftmp.53 = 0;
        <D.20656>:
        D.20661 = iftmp.53 != 0;
        D.20662 = (long int) D.20661;
        D.20663 = __builtin_expect (D.20662, 0);
        if (D.20663 != 0) goto <D.20664>; else goto <D.20665>;
        <D.20664>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.20665>:
        <D.20634>:
      }
      _objptr = _objptr + 4;
      <D.19465>:
      if (_objptr < _objptr_end) goto <D.19464>; else goto <D.19466>;
      <D.19466>:
    }
    <D.20592>:
    goto <D.19467>;
    <D.19468>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.54 = (unsigned int) _index;
        D.20667 = _index.54 * 4;
        _objptr = _objptr + D.20667;
        D.20668 = _index + 1;
        _bmap = _bmap >> D.20668;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.20671>; else goto <D.20669>;
          <D.20671>:
          D.20672 = sgen_ptr_in_nursery (__old);
          if (D.20672 == 0) goto <D.20673>; else goto <D.20669>;
          <D.20673>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object_concurrent (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.20674>; else goto <D.20675>;
          <D.20674>:
          if (__old != __copy) goto <D.20676>; else goto <D.20677>;
          <D.20676>:
          D.20678 = *_objptr;
          gc_debug_file.49 = gc_debug_file;
          fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20678, __old);
          gc_debug_file.49 = gc_debug_file;
          fflush (gc_debug_file.49);
          <D.20677>:
          <D.20675>:
          D.20682 = sgen_ptr_in_nursery (__copy);
          if (D.20682 != 0) goto <D.20683>; else goto <D.20680>;
          <D.20683>:
          D.20684 = sgen_ptr_in_nursery (_objptr);
          if (D.20684 == 0) goto <D.20685>; else goto <D.20680>;
          <D.20685>:
          iftmp.55 = 1;
          goto <D.20681>;
          <D.20680>:
          iftmp.55 = 0;
          <D.20681>:
          D.20686 = iftmp.55 != 0;
          D.20687 = (long int) D.20686;
          D.20688 = __builtin_expect (D.20687, 0);
          if (D.20688 != 0) goto <D.20689>; else goto <D.20690>;
          <D.20689>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.20690>:
          goto <D.20670>;
          <D.20669>:
          D.20694 = sgen_ptr_in_nursery (__old);
          if (D.20694 != 0) goto <D.20695>; else goto <D.20692>;
          <D.20695>:
          D.20696 = sgen_ptr_in_nursery (_objptr);
          if (D.20696 == 0) goto <D.20697>; else goto <D.20692>;
          <D.20697>:
          iftmp.56 = 1;
          goto <D.20693>;
          <D.20692>:
          iftmp.56 = 0;
          <D.20693>:
          D.20698 = iftmp.56 != 0;
          D.20699 = (long int) D.20698;
          D.20700 = __builtin_expect (D.20699, 0);
          if (D.20700 != 0) goto <D.20701>; else goto <D.20702>;
          <D.20701>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.20702>:
          <D.20670>:
        }
        _objptr = _objptr + 4;
      }
      goto <D.19478>;
      <D.19477>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.57 = (unsigned int) _index;
        D.20704 = _index.57 * 4;
        _objptr = _objptr + D.20704;
        D.20705 = _index + 1;
        _bmap = _bmap >> D.20705;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.20708>; else goto <D.20706>;
          <D.20708>:
          D.20709 = sgen_ptr_in_nursery (__old);
          if (D.20709 == 0) goto <D.20710>; else goto <D.20706>;
          <D.20710>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object_concurrent (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.20711>; else goto <D.20712>;
          <D.20711>:
          if (__old != __copy) goto <D.20713>; else goto <D.20714>;
          <D.20713>:
          D.20678 = *_objptr;
          gc_debug_file.49 = gc_debug_file;
          fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20678, __old);
          gc_debug_file.49 = gc_debug_file;
          fflush (gc_debug_file.49);
          <D.20714>:
          <D.20712>:
          D.20718 = sgen_ptr_in_nursery (__copy);
          if (D.20718 != 0) goto <D.20719>; else goto <D.20716>;
          <D.20719>:
          D.20720 = sgen_ptr_in_nursery (_objptr);
          if (D.20720 == 0) goto <D.20721>; else goto <D.20716>;
          <D.20721>:
          iftmp.58 = 1;
          goto <D.20717>;
          <D.20716>:
          iftmp.58 = 0;
          <D.20717>:
          D.20722 = iftmp.58 != 0;
          D.20723 = (long int) D.20722;
          D.20724 = __builtin_expect (D.20723, 0);
          if (D.20724 != 0) goto <D.20725>; else goto <D.20726>;
          <D.20725>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.20726>:
          goto <D.20707>;
          <D.20706>:
          D.20730 = sgen_ptr_in_nursery (__old);
          if (D.20730 != 0) goto <D.20731>; else goto <D.20728>;
          <D.20731>:
          D.20732 = sgen_ptr_in_nursery (_objptr);
          if (D.20732 == 0) goto <D.20733>; else goto <D.20728>;
          <D.20733>:
          iftmp.59 = 1;
          goto <D.20729>;
          <D.20728>:
          iftmp.59 = 0;
          <D.20729>:
          D.20734 = iftmp.59 != 0;
          D.20735 = (long int) D.20734;
          D.20736 = __builtin_expect (D.20735, 0);
          if (D.20736 != 0) goto <D.20737>; else goto <D.20738>;
          <D.20737>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.20738>:
          <D.20707>:
        }
        _objptr = _objptr + 4;
      }
      <D.19478>:
      if (_bmap != 0) goto <D.19477>; else goto <D.19479>;
      <D.19479>:
    }
    goto <D.19467>;
    <D.19480>:
    D.20739 = desc & 4294950912;
    if (D.20739 != 0) goto <D.20740>; else goto <D.20741>;
    <D.20740>:
    {
      int el_size;
      int etype;

      D.20742 = desc >> 3;
      D.20743 = (int) D.20742;
      el_size = D.20743 & 1023;
      desc.60 = (int) desc;
      etype = desc.60 & 49152;
      if (etype == 16384) goto <D.20745>; else goto <D.20746>;
      <D.20745>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.20747 = MEM[(struct MonoArray *)start].max_length;
        el_size.61 = (unsigned int) el_size;
        D.20749 = D.20747 * el_size.61;
        end_refs = p + D.20749;
        goto <D.19488>;
        <D.19487>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.20752>; else goto <D.20750>;
          <D.20752>:
          D.20753 = sgen_ptr_in_nursery (__old);
          if (D.20753 == 0) goto <D.20754>; else goto <D.20750>;
          <D.20754>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object_concurrent (p, __old, queue);
          __copy = *p;
          if (0 != 0) goto <D.20755>; else goto <D.20756>;
          <D.20755>:
          if (__old != __copy) goto <D.20757>; else goto <D.20758>;
          <D.20757>:
          D.20759 = *p;
          gc_debug_file.49 = gc_debug_file;
          fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", p, D.20759, __old);
          gc_debug_file.49 = gc_debug_file;
          fflush (gc_debug_file.49);
          <D.20758>:
          <D.20756>:
          D.20763 = sgen_ptr_in_nursery (__copy);
          if (D.20763 != 0) goto <D.20764>; else goto <D.20761>;
          <D.20764>:
          D.20765 = sgen_ptr_in_nursery (p);
          if (D.20765 == 0) goto <D.20766>; else goto <D.20761>;
          <D.20766>:
          iftmp.62 = 1;
          goto <D.20762>;
          <D.20761>:
          iftmp.62 = 0;
          <D.20762>:
          D.20767 = iftmp.62 != 0;
          D.20768 = (long int) D.20767;
          D.20769 = __builtin_expect (D.20768, 0);
          if (D.20769 != 0) goto <D.20770>; else goto <D.20771>;
          <D.20770>:
          sgen_add_to_global_remset (p, __copy);
          <D.20771>:
          goto <D.20751>;
          <D.20750>:
          D.20775 = sgen_ptr_in_nursery (__old);
          if (D.20775 != 0) goto <D.20776>; else goto <D.20773>;
          <D.20776>:
          D.20777 = sgen_ptr_in_nursery (p);
          if (D.20777 == 0) goto <D.20778>; else goto <D.20773>;
          <D.20778>:
          iftmp.63 = 1;
          goto <D.20774>;
          <D.20773>:
          iftmp.63 = 0;
          <D.20774>:
          D.20779 = iftmp.63 != 0;
          D.20780 = (long int) D.20779;
          D.20781 = __builtin_expect (D.20780, 0);
          if (D.20781 != 0) goto <D.20782>; else goto <D.20783>;
          <D.20782>:
          sgen_add_to_global_remset (p, __old);
          <D.20783>:
          <D.20751>:
        }
        p = p + 4;
        <D.19488>:
        if (p < end_refs) goto <D.19487>; else goto <D.19489>;
        <D.19489>:
      }
      goto <D.20784>;
      <D.20746>:
      if (etype == 32768) goto <D.20785>; else goto <D.20786>;
      <D.20785>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.20593 = desc >> 16;
        D.20787 = (int) D.20593;
        offset = D.20787 & 255;
        D.20596 = desc >> 24;
        num_refs = (int) D.20596;
        e_start = start + 16;
        D.20747 = MEM[(struct MonoArray *)start].max_length;
        el_size.61 = (unsigned int) el_size;
        D.20749 = D.20747 * el_size.61;
        e_end = e_start + D.20749;
        goto <D.19502>;
        <D.19501>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.64 = (unsigned int) offset;
          D.20789 = offset.64 * 4;
          p = p + D.20789;
          i = 0;
          goto <D.19499>;
          <D.19498>:
          {
            void * __old;
            void * __copy;

            i.65 = (unsigned int) i;
            D.20791 = i.65 * 4;
            D.20792 = p + D.20791;
            __old = *D.20792;
            if (__old != 0B) goto <D.20795>; else goto <D.20793>;
            <D.20795>:
            D.20796 = sgen_ptr_in_nursery (__old);
            if (D.20796 == 0) goto <D.20797>; else goto <D.20793>;
            <D.20797>:
            __builtin_prefetch (__old);
            i.65 = (unsigned int) i;
            D.20791 = i.65 * 4;
            D.20792 = p + D.20791;
            major_copy_or_mark_object_concurrent (D.20792, __old, queue);
            i.65 = (unsigned int) i;
            D.20791 = i.65 * 4;
            D.20792 = p + D.20791;
            __copy = *D.20792;
            if (0 != 0) goto <D.20798>; else goto <D.20799>;
            <D.20798>:
            if (__old != __copy) goto <D.20800>; else goto <D.20801>;
            <D.20800>:
            i.65 = (unsigned int) i;
            D.20791 = i.65 * 4;
            D.20792 = p + D.20791;
            D.20802 = *D.20792;
            i.65 = (unsigned int) i;
            D.20791 = i.65 * 4;
            D.20792 = p + D.20791;
            gc_debug_file.49 = gc_debug_file;
            fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", D.20792, D.20802, __old);
            gc_debug_file.49 = gc_debug_file;
            fflush (gc_debug_file.49);
            <D.20801>:
            <D.20799>:
            D.20806 = sgen_ptr_in_nursery (__copy);
            if (D.20806 != 0) goto <D.20807>; else goto <D.20804>;
            <D.20807>:
            i.65 = (unsigned int) i;
            D.20791 = i.65 * 4;
            D.20808 = p + D.20791;
            D.20809 = sgen_ptr_in_nursery (D.20808);
            if (D.20809 == 0) goto <D.20810>; else goto <D.20804>;
            <D.20810>:
            iftmp.66 = 1;
            goto <D.20805>;
            <D.20804>:
            iftmp.66 = 0;
            <D.20805>:
            D.20811 = iftmp.66 != 0;
            D.20812 = (long int) D.20811;
            D.20813 = __builtin_expect (D.20812, 0);
            if (D.20813 != 0) goto <D.20814>; else goto <D.20815>;
            <D.20814>:
            i.65 = (unsigned int) i;
            D.20791 = i.65 * 4;
            D.20816 = p + D.20791;
            sgen_add_to_global_remset (D.20816, __copy);
            <D.20815>:
            goto <D.20794>;
            <D.20793>:
            D.20820 = sgen_ptr_in_nursery (__old);
            if (D.20820 != 0) goto <D.20821>; else goto <D.20818>;
            <D.20821>:
            i.65 = (unsigned int) i;
            D.20791 = i.65 * 4;
            D.20808 = p + D.20791;
            D.20822 = sgen_ptr_in_nursery (D.20808);
            if (D.20822 == 0) goto <D.20823>; else goto <D.20818>;
            <D.20823>:
            iftmp.67 = 1;
            goto <D.20819>;
            <D.20818>:
            iftmp.67 = 0;
            <D.20819>:
            D.20824 = iftmp.67 != 0;
            D.20825 = (long int) D.20824;
            D.20826 = __builtin_expect (D.20825, 0);
            if (D.20826 != 0) goto <D.20827>; else goto <D.20828>;
            <D.20827>:
            i.65 = (unsigned int) i;
            D.20791 = i.65 * 4;
            D.20816 = p + D.20791;
            sgen_add_to_global_remset (D.20816, __old);
            <D.20828>:
            <D.20794>:
          }
          i = i + 1;
          <D.19499>:
          if (i < num_refs) goto <D.19498>; else goto <D.19500>;
          <D.19500>:
          el_size.68 = (sizetype) el_size;
          e_start = e_start + el_size.68;
        }
        <D.19502>:
        if (e_start < e_end) goto <D.19501>; else goto <D.19503>;
        <D.19503>:
      }
      goto <D.20830>;
      <D.20786>:
      if (etype == 49152) goto <D.20831>; else goto <D.20832>;
      <D.20831>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.20747 = MEM[(struct MonoArray *)start].max_length;
        el_size.61 = (unsigned int) el_size;
        D.20749 = D.20747 * el_size.61;
        e_end = e_start + D.20749;
        goto <D.19514>;
        <D.19513>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.19511>;
          <D.19510>:
          D.20833 = _bmap & 1;
          if (D.20833 != 0) goto <D.20834>; else goto <D.20835>;
          <D.20834>:
          {
            void * __old;
            void * __copy;

            __old = *p;
            if (__old != 0B) goto <D.20838>; else goto <D.20836>;
            <D.20838>:
            D.20839 = sgen_ptr_in_nursery (__old);
            if (D.20839 == 0) goto <D.20840>; else goto <D.20836>;
            <D.20840>:
            __builtin_prefetch (__old);
            major_copy_or_mark_object_concurrent (p, __old, queue);
            __copy = *p;
            if (0 != 0) goto <D.20841>; else goto <D.20842>;
            <D.20841>:
            if (__old != __copy) goto <D.20843>; else goto <D.20844>;
            <D.20843>:
            D.20845 = *p;
            gc_debug_file.49 = gc_debug_file;
            fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", p, D.20845, __old);
            gc_debug_file.49 = gc_debug_file;
            fflush (gc_debug_file.49);
            <D.20844>:
            <D.20842>:
            D.20849 = sgen_ptr_in_nursery (__copy);
            if (D.20849 != 0) goto <D.20850>; else goto <D.20847>;
            <D.20850>:
            D.20851 = sgen_ptr_in_nursery (p);
            if (D.20851 == 0) goto <D.20852>; else goto <D.20847>;
            <D.20852>:
            iftmp.69 = 1;
            goto <D.20848>;
            <D.20847>:
            iftmp.69 = 0;
            <D.20848>:
            D.20853 = iftmp.69 != 0;
            D.20854 = (long int) D.20853;
            D.20855 = __builtin_expect (D.20854, 0);
            if (D.20855 != 0) goto <D.20856>; else goto <D.20857>;
            <D.20856>:
            sgen_add_to_global_remset (p, __copy);
            <D.20857>:
            goto <D.20837>;
            <D.20836>:
            D.20861 = sgen_ptr_in_nursery (__old);
            if (D.20861 != 0) goto <D.20862>; else goto <D.20859>;
            <D.20862>:
            D.20863 = sgen_ptr_in_nursery (p);
            if (D.20863 == 0) goto <D.20864>; else goto <D.20859>;
            <D.20864>:
            iftmp.70 = 1;
            goto <D.20860>;
            <D.20859>:
            iftmp.70 = 0;
            <D.20860>:
            D.20865 = iftmp.70 != 0;
            D.20866 = (long int) D.20865;
            D.20867 = __builtin_expect (D.20866, 0);
            if (D.20867 != 0) goto <D.20868>; else goto <D.20869>;
            <D.20868>:
            sgen_add_to_global_remset (p, __old);
            <D.20869>:
            <D.20837>:
          }
          <D.20835>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.19511>:
          if (_bmap != 0) goto <D.19510>; else goto <D.19512>;
          <D.19512>:
          el_size.68 = (sizetype) el_size;
          e_start = e_start + el_size.68;
        }
        <D.19514>:
        if (e_start < e_end) goto <D.19513>; else goto <D.19515>;
        <D.19515>:
      }
      <D.20832>:
      <D.20830>:
      <D.20784>:
    }
    <D.20741>:
    goto <D.19467>;
    <D.19516>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.19522>;
      <D.19521>:
      D.20870 = _bmap & 1;
      if (D.20870 != 0) goto <D.20871>; else goto <D.20872>;
      <D.20871>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.20875>; else goto <D.20873>;
        <D.20875>:
        D.20876 = sgen_ptr_in_nursery (__old);
        if (D.20876 == 0) goto <D.20877>; else goto <D.20873>;
        <D.20877>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object_concurrent (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.20878>; else goto <D.20879>;
        <D.20878>:
        if (__old != __copy) goto <D.20880>; else goto <D.20881>;
        <D.20880>:
        D.20882 = *_objptr;
        gc_debug_file.49 = gc_debug_file;
        fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20882, __old);
        gc_debug_file.49 = gc_debug_file;
        fflush (gc_debug_file.49);
        <D.20881>:
        <D.20879>:
        D.20886 = sgen_ptr_in_nursery (__copy);
        if (D.20886 != 0) goto <D.20887>; else goto <D.20884>;
        <D.20887>:
        D.20888 = sgen_ptr_in_nursery (_objptr);
        if (D.20888 == 0) goto <D.20889>; else goto <D.20884>;
        <D.20889>:
        iftmp.71 = 1;
        goto <D.20885>;
        <D.20884>:
        iftmp.71 = 0;
        <D.20885>:
        D.20890 = iftmp.71 != 0;
        D.20891 = (long int) D.20890;
        D.20892 = __builtin_expect (D.20891, 0);
        if (D.20892 != 0) goto <D.20893>; else goto <D.20894>;
        <D.20893>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20894>:
        goto <D.20874>;
        <D.20873>:
        D.20898 = sgen_ptr_in_nursery (__old);
        if (D.20898 != 0) goto <D.20899>; else goto <D.20896>;
        <D.20899>:
        D.20900 = sgen_ptr_in_nursery (_objptr);
        if (D.20900 == 0) goto <D.20901>; else goto <D.20896>;
        <D.20901>:
        iftmp.72 = 1;
        goto <D.20897>;
        <D.20896>:
        iftmp.72 = 0;
        <D.20897>:
        D.20902 = iftmp.72 != 0;
        D.20903 = (long int) D.20902;
        D.20904 = __builtin_expect (D.20903, 0);
        if (D.20904 != 0) goto <D.20905>; else goto <D.20906>;
        <D.20905>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.20906>:
        <D.20874>:
      }
      <D.20872>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.19522>:
      if (_bmap != 0) goto <D.19521>; else goto <D.19523>;
      <D.19523>:
    }
    goto <D.19467>;
    <D.19524>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.20907 = *bitmap_data;
      D.20908 = D.20907 + 4294967295;
      bwords = (int) D.20908;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.20909>; else goto <D.20910>;
      <D.20909>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.20911 = myobj->vtable;
        D.20912 = D.20911->klass;
        D.20913 = D.20912->name;
        D.20911 = myobj->vtable;
        D.20912 = D.20911->klass;
        D.20914 = D.20912->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.20914, D.20913);
      }
      <D.20910>:
      goto <D.19537>;
      <D.19536>:
      {
        gsize _bmap;

        bitmap_data.73 = bitmap_data;
        bitmap_data = bitmap_data.73 + 4;
        _bmap = *bitmap_data.73;
        _objptr = start_run;
        goto <D.19534>;
        <D.19533>:
        D.20916 = _bmap & 1;
        if (D.20916 != 0) goto <D.20917>; else goto <D.20918>;
        <D.20917>:
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.20921>; else goto <D.20919>;
          <D.20921>:
          D.20922 = sgen_ptr_in_nursery (__old);
          if (D.20922 == 0) goto <D.20923>; else goto <D.20919>;
          <D.20923>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object_concurrent (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.20924>; else goto <D.20925>;
          <D.20924>:
          if (__old != __copy) goto <D.20926>; else goto <D.20927>;
          <D.20926>:
          D.20928 = *_objptr;
          gc_debug_file.49 = gc_debug_file;
          fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20928, __old);
          gc_debug_file.49 = gc_debug_file;
          fflush (gc_debug_file.49);
          <D.20927>:
          <D.20925>:
          D.20932 = sgen_ptr_in_nursery (__copy);
          if (D.20932 != 0) goto <D.20933>; else goto <D.20930>;
          <D.20933>:
          D.20934 = sgen_ptr_in_nursery (_objptr);
          if (D.20934 == 0) goto <D.20935>; else goto <D.20930>;
          <D.20935>:
          iftmp.74 = 1;
          goto <D.20931>;
          <D.20930>:
          iftmp.74 = 0;
          <D.20931>:
          D.20936 = iftmp.74 != 0;
          D.20937 = (long int) D.20936;
          D.20938 = __builtin_expect (D.20937, 0);
          if (D.20938 != 0) goto <D.20939>; else goto <D.20940>;
          <D.20939>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.20940>:
          goto <D.20920>;
          <D.20919>:
          D.20944 = sgen_ptr_in_nursery (__old);
          if (D.20944 != 0) goto <D.20945>; else goto <D.20942>;
          <D.20945>:
          D.20946 = sgen_ptr_in_nursery (_objptr);
          if (D.20946 == 0) goto <D.20947>; else goto <D.20942>;
          <D.20947>:
          iftmp.75 = 1;
          goto <D.20943>;
          <D.20942>:
          iftmp.75 = 0;
          <D.20943>:
          D.20948 = iftmp.75 != 0;
          D.20949 = (long int) D.20948;
          D.20950 = __builtin_expect (D.20949, 0);
          if (D.20950 != 0) goto <D.20951>; else goto <D.20952>;
          <D.20951>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.20952>:
          <D.20920>:
        }
        <D.20918>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.19534>:
        if (_bmap != 0) goto <D.19533>; else goto <D.19535>;
        <D.19535>:
        start_run = start_run + 128;
      }
      <D.19537>:
      bwords.76 = bwords;
      bwords = bwords.76 + -1;
      if (bwords.76 > 0) goto <D.19536>; else goto <D.19538>;
      <D.19538>:
    }
    goto <D.19467>;
    <D.19539>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.20954 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.20954);
      mbitmap_data.77 = mbitmap_data;
      mbitmap_data = mbitmap_data.77 + 4;
      D.20956 = *mbitmap_data.77;
      D.20957 = D.20956 + 4294967295;
      mbwords = (int) D.20957;
      D.20958 = vt->klass;
      el_size = mono_array_element_size (D.20958);
      e_start = start + 16;
      D.20747 = MEM[(struct MonoArray *)start].max_length;
      el_size.78 = (unsigned int) el_size;
      D.20960 = D.20747 * el_size.78;
      e_end = e_start + D.20960;
      if (0 != 0) goto <D.20961>; else goto <D.20962>;
      <D.20961>:
      D.20958 = vt->klass;
      D.20963 = D.20958->name;
      D.20958 = vt->klass;
      D.20964 = D.20958->name_space;
      D.20954 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.20954, D.20964, D.20963);
      <D.20962>:
      goto <D.19559>;
      <D.19558>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.79 = bitmap_data;
          bitmap_data = bitmap_data.79 + 4;
          _bmap = *bitmap_data.79;
          start_run = _objptr;
          goto <D.19553>;
          <D.19552>:
          D.20966 = _bmap & 1;
          if (D.20966 != 0) goto <D.20967>; else goto <D.20968>;
          <D.20967>:
          {
            void * __old;
            void * __copy;

            __old = *_objptr;
            if (__old != 0B) goto <D.20971>; else goto <D.20969>;
            <D.20971>:
            D.20972 = sgen_ptr_in_nursery (__old);
            if (D.20972 == 0) goto <D.20973>; else goto <D.20969>;
            <D.20973>:
            __builtin_prefetch (__old);
            major_copy_or_mark_object_concurrent (_objptr, __old, queue);
            __copy = *_objptr;
            if (0 != 0) goto <D.20974>; else goto <D.20975>;
            <D.20974>:
            if (__old != __copy) goto <D.20976>; else goto <D.20977>;
            <D.20976>:
            D.20978 = *_objptr;
            gc_debug_file.49 = gc_debug_file;
            fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20978, __old);
            gc_debug_file.49 = gc_debug_file;
            fflush (gc_debug_file.49);
            <D.20977>:
            <D.20975>:
            D.20982 = sgen_ptr_in_nursery (__copy);
            if (D.20982 != 0) goto <D.20983>; else goto <D.20980>;
            <D.20983>:
            D.20984 = sgen_ptr_in_nursery (_objptr);
            if (D.20984 == 0) goto <D.20985>; else goto <D.20980>;
            <D.20985>:
            iftmp.80 = 1;
            goto <D.20981>;
            <D.20980>:
            iftmp.80 = 0;
            <D.20981>:
            D.20986 = iftmp.80 != 0;
            D.20987 = (long int) D.20986;
            D.20988 = __builtin_expect (D.20987, 0);
            if (D.20988 != 0) goto <D.20989>; else goto <D.20990>;
            <D.20989>:
            sgen_add_to_global_remset (_objptr, __copy);
            <D.20990>:
            goto <D.20970>;
            <D.20969>:
            D.20994 = sgen_ptr_in_nursery (__old);
            if (D.20994 != 0) goto <D.20995>; else goto <D.20992>;
            <D.20995>:
            D.20996 = sgen_ptr_in_nursery (_objptr);
            if (D.20996 == 0) goto <D.20997>; else goto <D.20992>;
            <D.20997>:
            iftmp.81 = 1;
            goto <D.20993>;
            <D.20992>:
            iftmp.81 = 0;
            <D.20993>:
            D.20998 = iftmp.81 != 0;
            D.20999 = (long int) D.20998;
            D.21000 = __builtin_expect (D.20999, 0);
            if (D.21000 != 0) goto <D.21001>; else goto <D.21002>;
            <D.21001>:
            sgen_add_to_global_remset (_objptr, __old);
            <D.21002>:
            <D.20970>:
          }
          <D.20968>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.19553>:
          if (_bmap != 0) goto <D.19552>; else goto <D.19554>;
          <D.19554>:
          _objptr = start_run + 128;
        }
        <D.19556>:
        bwords.82 = bwords;
        bwords = bwords.82 + 4294967295;
        if (bwords.82 != 0) goto <D.19555>; else goto <D.19557>;
        <D.19557>:
        el_size.83 = (sizetype) el_size;
        e_start = e_start + el_size.83;
      }
      <D.19559>:
      if (e_start < e_end) goto <D.19558>; else goto <D.19560>;
      <D.19560>:
    }
    goto <D.19467>;
    <D.19561>:
    goto <D.19467>;
    <D.19562>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.19467>:
  }
}


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

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


major_scan_object (char * start, struct SgenGrayQueue * queue)
{
  unsigned int D.21007;
  unsigned int D.21008;
  unsigned int D.21009;
  unsigned int D.21010;
  unsigned int D.21013;
  unsigned int D.21014;
  unsigned int D.21015;
  unsigned int D.21016;
  unsigned int D.21017;
  void * D.21024;
  struct FILE * gc_debug_file.84;
  int iftmp.85;
  int D.21029;
  int D.21031;
  _Bool D.21033;
  long int D.21034;
  long int D.21035;
  int iftmp.86;
  int D.21050;
  int D.21052;
  _Bool D.21054;
  long int D.21055;
  long int D.21056;
  unsigned int _index.87;
  unsigned int D.21063;
  int D.21064;
  void * D.21071;
  int iftmp.88;
  int D.21075;
  int D.21077;
  _Bool D.21079;
  long int D.21080;
  long int D.21081;
  unsigned int _index.89;
  unsigned int D.21088;
  int D.21089;
  int iftmp.90;
  int D.21099;
  int D.21101;
  _Bool D.21103;
  long int D.21104;
  long int D.21105;
  unsigned int D.21111;
  unsigned int D.21114;
  int D.21115;
  int desc.91;
  unsigned int D.21119;
  unsigned int el_size.92;
  unsigned int D.21121;
  void * D.21128;
  int iftmp.93;
  int D.21132;
  int D.21134;
  _Bool D.21136;
  long int D.21137;
  long int D.21138;
  int D.21147;
  unsigned int offset.94;
  unsigned int D.21149;
  unsigned int i.95;
  unsigned int D.21151;
  void * * D.21152;
  void * D.21159;
  int iftmp.96;
  int D.21163;
  void * D.21165;
  int D.21166;
  _Bool D.21168;
  long int D.21169;
  long int D.21170;
  void * D.21173;
  sizetype el_size.97;
  unsigned int D.21181;
  void * D.21190;
  int iftmp.98;
  int D.21194;
  int D.21196;
  _Bool D.21198;
  long int D.21199;
  long int D.21200;
  unsigned int D.21206;
  void * D.21215;
  int iftmp.99;
  int D.21219;
  int D.21221;
  _Bool D.21223;
  long int D.21224;
  long int D.21225;
  unsigned int D.21231;
  unsigned int D.21232;
  struct MonoVTable * D.21235;
  struct MonoClass * D.21236;
  const char * D.21237;
  const char * D.21238;
  gsize * bitmap_data.100;
  unsigned int D.21240;
  void * D.21249;
  int iftmp.101;
  int D.21253;
  int D.21255;
  _Bool D.21257;
  long int D.21258;
  long int D.21259;
  int bwords.102;
  unsigned int D.21266;
  gsize * mbitmap_data.103;
  unsigned int D.21268;
  unsigned int D.21269;
  struct MonoClass * D.21270;
  unsigned int el_size.104;
  unsigned int D.21272;
  const char * D.21275;
  const char * D.21276;
  gsize * bitmap_data.105;
  unsigned int D.21278;
  void * D.21287;
  int iftmp.106;
  int D.21291;
  int D.21293;
  _Bool D.21295;
  long int D.21296;
  long int D.21297;
  unsigned int bwords.107;
  sizetype el_size.108;

  {
    struct GCVTable * vt;
    mword desc;

    D.21007 = MEM[(mword *)start];
    D.21008 = D.21007 & 4294967292;
    vt = (struct GCVTable *) D.21008;
    desc = vt->desc;
    D.21009 = desc & 7;
    switch (D.21009) <default: <D.19449>, case 1: <D.19344>, case 2: <D.19355>, case 3: <D.19411>, case 4: <D.19367>, case 5: <D.19403>, case 6: <D.19426>, case 7: <D.19448>>
    <D.19344>:
    D.21010 = desc & 4294901760;
    if (D.21010 != 0) goto <D.21011>; else goto <D.21012>;
    <D.21011>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.21013 = desc >> 16;
      D.21014 = D.21013 & 255;
      D.21015 = D.21014 * 4;
      _objptr = _objptr + D.21015;
      D.21016 = desc >> 24;
      D.21017 = D.21016 * 4;
      _objptr_end = _objptr + D.21017;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21018>; else goto <D.21019>;
        <D.21018>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21020>; else goto <D.21021>;
        <D.21020>:
        if (__old != __copy) goto <D.21022>; else goto <D.21023>;
        <D.21022>:
        D.21024 = *_objptr;
        gc_debug_file.84 = gc_debug_file;
        fprintf (gc_debug_file.84, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21024, __old);
        gc_debug_file.84 = gc_debug_file;
        fflush (gc_debug_file.84);
        <D.21023>:
        <D.21021>:
        D.21029 = sgen_ptr_in_nursery (__copy);
        if (D.21029 != 0) goto <D.21030>; else goto <D.21027>;
        <D.21030>:
        D.21031 = sgen_ptr_in_nursery (_objptr);
        if (D.21031 == 0) goto <D.21032>; else goto <D.21027>;
        <D.21032>:
        iftmp.85 = 1;
        goto <D.21028>;
        <D.21027>:
        iftmp.85 = 0;
        <D.21028>:
        D.21033 = iftmp.85 != 0;
        D.21034 = (long int) D.21033;
        D.21035 = __builtin_expect (D.21034, 0);
        if (D.21035 != 0) goto <D.21036>; else goto <D.21037>;
        <D.21036>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21037>:
        goto <D.21038>;
        <D.21019>:
        if (0 != 0) goto <D.21039>; else goto <D.21040>;
        <D.21039>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.21040>:
        <D.21038>:
      }
      _objptr = _objptr + 4;
      goto <D.19352>;
      <D.19351>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21041>; else goto <D.21042>;
        <D.21041>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21043>; else goto <D.21044>;
        <D.21043>:
        if (__old != __copy) goto <D.21045>; else goto <D.21046>;
        <D.21045>:
        D.21024 = *_objptr;
        gc_debug_file.84 = gc_debug_file;
        fprintf (gc_debug_file.84, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21024, __old);
        gc_debug_file.84 = gc_debug_file;
        fflush (gc_debug_file.84);
        <D.21046>:
        <D.21044>:
        D.21050 = sgen_ptr_in_nursery (__copy);
        if (D.21050 != 0) goto <D.21051>; else goto <D.21048>;
        <D.21051>:
        D.21052 = sgen_ptr_in_nursery (_objptr);
        if (D.21052 == 0) goto <D.21053>; else goto <D.21048>;
        <D.21053>:
        iftmp.86 = 1;
        goto <D.21049>;
        <D.21048>:
        iftmp.86 = 0;
        <D.21049>:
        D.21054 = iftmp.86 != 0;
        D.21055 = (long int) D.21054;
        D.21056 = __builtin_expect (D.21055, 0);
        if (D.21056 != 0) goto <D.21057>; else goto <D.21058>;
        <D.21057>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21058>:
        goto <D.21059>;
        <D.21042>:
        if (0 != 0) goto <D.21060>; else goto <D.21061>;
        <D.21060>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.21061>:
        <D.21059>:
      }
      _objptr = _objptr + 4;
      <D.19352>:
      if (_objptr < _objptr_end) goto <D.19351>; else goto <D.19353>;
      <D.19353>:
    }
    <D.21012>:
    goto <D.19354>;
    <D.19355>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.87 = (unsigned int) _index;
        D.21063 = _index.87 * 4;
        _objptr = _objptr + D.21063;
        D.21064 = _index + 1;
        _bmap = _bmap >> D.21064;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21065>; else goto <D.21066>;
          <D.21065>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21067>; else goto <D.21068>;
          <D.21067>:
          if (__old != __copy) goto <D.21069>; else goto <D.21070>;
          <D.21069>:
          D.21071 = *_objptr;
          gc_debug_file.84 = gc_debug_file;
          fprintf (gc_debug_file.84, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21071, __old);
          gc_debug_file.84 = gc_debug_file;
          fflush (gc_debug_file.84);
          <D.21070>:
          <D.21068>:
          D.21075 = sgen_ptr_in_nursery (__copy);
          if (D.21075 != 0) goto <D.21076>; else goto <D.21073>;
          <D.21076>:
          D.21077 = sgen_ptr_in_nursery (_objptr);
          if (D.21077 == 0) goto <D.21078>; else goto <D.21073>;
          <D.21078>:
          iftmp.88 = 1;
          goto <D.21074>;
          <D.21073>:
          iftmp.88 = 0;
          <D.21074>:
          D.21079 = iftmp.88 != 0;
          D.21080 = (long int) D.21079;
          D.21081 = __builtin_expect (D.21080, 0);
          if (D.21081 != 0) goto <D.21082>; else goto <D.21083>;
          <D.21082>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21083>:
          goto <D.21084>;
          <D.21066>:
          if (0 != 0) goto <D.21085>; else goto <D.21086>;
          <D.21085>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.21086>:
          <D.21084>:
        }
        _objptr = _objptr + 4;
      }
      goto <D.19365>;
      <D.19364>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.89 = (unsigned int) _index;
        D.21088 = _index.89 * 4;
        _objptr = _objptr + D.21088;
        D.21089 = _index + 1;
        _bmap = _bmap >> D.21089;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21090>; else goto <D.21091>;
          <D.21090>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21092>; else goto <D.21093>;
          <D.21092>:
          if (__old != __copy) goto <D.21094>; else goto <D.21095>;
          <D.21094>:
          D.21071 = *_objptr;
          gc_debug_file.84 = gc_debug_file;
          fprintf (gc_debug_file.84, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21071, __old);
          gc_debug_file.84 = gc_debug_file;
          fflush (gc_debug_file.84);
          <D.21095>:
          <D.21093>:
          D.21099 = sgen_ptr_in_nursery (__copy);
          if (D.21099 != 0) goto <D.21100>; else goto <D.21097>;
          <D.21100>:
          D.21101 = sgen_ptr_in_nursery (_objptr);
          if (D.21101 == 0) goto <D.21102>; else goto <D.21097>;
          <D.21102>:
          iftmp.90 = 1;
          goto <D.21098>;
          <D.21097>:
          iftmp.90 = 0;
          <D.21098>:
          D.21103 = iftmp.90 != 0;
          D.21104 = (long int) D.21103;
          D.21105 = __builtin_expect (D.21104, 0);
          if (D.21105 != 0) goto <D.21106>; else goto <D.21107>;
          <D.21106>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21107>:
          goto <D.21108>;
          <D.21091>:
          if (0 != 0) goto <D.21109>; else goto <D.21110>;
          <D.21109>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.21110>:
          <D.21108>:
        }
        _objptr = _objptr + 4;
      }
      <D.19365>:
      if (_bmap != 0) goto <D.19364>; else goto <D.19366>;
      <D.19366>:
    }
    goto <D.19354>;
    <D.19367>:
    D.21111 = desc & 4294950912;
    if (D.21111 != 0) goto <D.21112>; else goto <D.21113>;
    <D.21112>:
    {
      int el_size;
      int etype;

      D.21114 = desc >> 3;
      D.21115 = (int) D.21114;
      el_size = D.21115 & 1023;
      desc.91 = (int) desc;
      etype = desc.91 & 49152;
      if (etype == 16384) goto <D.21117>; else goto <D.21118>;
      <D.21117>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.21119 = MEM[(struct MonoArray *)start].max_length;
        el_size.92 = (unsigned int) el_size;
        D.21121 = D.21119 * el_size.92;
        end_refs = p + D.21121;
        goto <D.19375>;
        <D.19374>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.21122>; else goto <D.21123>;
          <D.21122>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object (p, __old, queue);
          __copy = *p;
          if (0 != 0) goto <D.21124>; else goto <D.21125>;
          <D.21124>:
          if (__old != __copy) goto <D.21126>; else goto <D.21127>;
          <D.21126>:
          D.21128 = *p;
          gc_debug_file.84 = gc_debug_file;
          fprintf (gc_debug_file.84, "Overwrote field at %p with %p (was: %p)\n", p, D.21128, __old);
          gc_debug_file.84 = gc_debug_file;
          fflush (gc_debug_file.84);
          <D.21127>:
          <D.21125>:
          D.21132 = sgen_ptr_in_nursery (__copy);
          if (D.21132 != 0) goto <D.21133>; else goto <D.21130>;
          <D.21133>:
          D.21134 = sgen_ptr_in_nursery (p);
          if (D.21134 == 0) goto <D.21135>; else goto <D.21130>;
          <D.21135>:
          iftmp.93 = 1;
          goto <D.21131>;
          <D.21130>:
          iftmp.93 = 0;
          <D.21131>:
          D.21136 = iftmp.93 != 0;
          D.21137 = (long int) D.21136;
          D.21138 = __builtin_expect (D.21137, 0);
          if (D.21138 != 0) goto <D.21139>; else goto <D.21140>;
          <D.21139>:
          sgen_add_to_global_remset (p, __copy);
          <D.21140>:
          goto <D.21141>;
          <D.21123>:
          if (0 != 0) goto <D.21142>; else goto <D.21143>;
          <D.21142>:
          sgen_add_to_global_remset (p, __old);
          <D.21143>:
          <D.21141>:
        }
        p = p + 4;
        <D.19375>:
        if (p < end_refs) goto <D.19374>; else goto <D.19376>;
        <D.19376>:
      }
      goto <D.21144>;
      <D.21118>:
      if (etype == 32768) goto <D.21145>; else goto <D.21146>;
      <D.21145>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.21013 = desc >> 16;
        D.21147 = (int) D.21013;
        offset = D.21147 & 255;
        D.21016 = desc >> 24;
        num_refs = (int) D.21016;
        e_start = start + 16;
        D.21119 = MEM[(struct MonoArray *)start].max_length;
        el_size.92 = (unsigned int) el_size;
        D.21121 = D.21119 * el_size.92;
        e_end = e_start + D.21121;
        goto <D.19389>;
        <D.19388>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.94 = (unsigned int) offset;
          D.21149 = offset.94 * 4;
          p = p + D.21149;
          i = 0;
          goto <D.19386>;
          <D.19385>:
          {
            void * __old;
            void * __copy;

            i.95 = (unsigned int) i;
            D.21151 = i.95 * 4;
            D.21152 = p + D.21151;
            __old = *D.21152;
            if (__old != 0B) goto <D.21153>; else goto <D.21154>;
            <D.21153>:
            __builtin_prefetch (__old);
            i.95 = (unsigned int) i;
            D.21151 = i.95 * 4;
            D.21152 = p + D.21151;
            major_copy_or_mark_object (D.21152, __old, queue);
            i.95 = (unsigned int) i;
            D.21151 = i.95 * 4;
            D.21152 = p + D.21151;
            __copy = *D.21152;
            if (0 != 0) goto <D.21155>; else goto <D.21156>;
            <D.21155>:
            if (__old != __copy) goto <D.21157>; else goto <D.21158>;
            <D.21157>:
            i.95 = (unsigned int) i;
            D.21151 = i.95 * 4;
            D.21152 = p + D.21151;
            D.21159 = *D.21152;
            i.95 = (unsigned int) i;
            D.21151 = i.95 * 4;
            D.21152 = p + D.21151;
            gc_debug_file.84 = gc_debug_file;
            fprintf (gc_debug_file.84, "Overwrote field at %p with %p (was: %p)\n", D.21152, D.21159, __old);
            gc_debug_file.84 = gc_debug_file;
            fflush (gc_debug_file.84);
            <D.21158>:
            <D.21156>:
            D.21163 = sgen_ptr_in_nursery (__copy);
            if (D.21163 != 0) goto <D.21164>; else goto <D.21161>;
            <D.21164>:
            i.95 = (unsigned int) i;
            D.21151 = i.95 * 4;
            D.21165 = p + D.21151;
            D.21166 = sgen_ptr_in_nursery (D.21165);
            if (D.21166 == 0) goto <D.21167>; else goto <D.21161>;
            <D.21167>:
            iftmp.96 = 1;
            goto <D.21162>;
            <D.21161>:
            iftmp.96 = 0;
            <D.21162>:
            D.21168 = iftmp.96 != 0;
            D.21169 = (long int) D.21168;
            D.21170 = __builtin_expect (D.21169, 0);
            if (D.21170 != 0) goto <D.21171>; else goto <D.21172>;
            <D.21171>:
            i.95 = (unsigned int) i;
            D.21151 = i.95 * 4;
            D.21173 = p + D.21151;
            sgen_add_to_global_remset (D.21173, __copy);
            <D.21172>:
            goto <D.21174>;
            <D.21154>:
            if (0 != 0) goto <D.21175>; else goto <D.21176>;
            <D.21175>:
            i.95 = (unsigned int) i;
            D.21151 = i.95 * 4;
            D.21173 = p + D.21151;
            sgen_add_to_global_remset (D.21173, __old);
            <D.21176>:
            <D.21174>:
          }
          i = i + 1;
          <D.19386>:
          if (i < num_refs) goto <D.19385>; else goto <D.19387>;
          <D.19387>:
          el_size.97 = (sizetype) el_size;
          e_start = e_start + el_size.97;
        }
        <D.19389>:
        if (e_start < e_end) goto <D.19388>; else goto <D.19390>;
        <D.19390>:
      }
      goto <D.21178>;
      <D.21146>:
      if (etype == 49152) goto <D.21179>; else goto <D.21180>;
      <D.21179>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.21119 = MEM[(struct MonoArray *)start].max_length;
        el_size.92 = (unsigned int) el_size;
        D.21121 = D.21119 * el_size.92;
        e_end = e_start + D.21121;
        goto <D.19401>;
        <D.19400>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.19398>;
          <D.19397>:
          D.21181 = _bmap & 1;
          if (D.21181 != 0) goto <D.21182>; else goto <D.21183>;
          <D.21182>:
          {
            void * __old;
            void * __copy;

            __old = *p;
            if (__old != 0B) goto <D.21184>; else goto <D.21185>;
            <D.21184>:
            __builtin_prefetch (__old);
            major_copy_or_mark_object (p, __old, queue);
            __copy = *p;
            if (0 != 0) goto <D.21186>; else goto <D.21187>;
            <D.21186>:
            if (__old != __copy) goto <D.21188>; else goto <D.21189>;
            <D.21188>:
            D.21190 = *p;
            gc_debug_file.84 = gc_debug_file;
            fprintf (gc_debug_file.84, "Overwrote field at %p with %p (was: %p)\n", p, D.21190, __old);
            gc_debug_file.84 = gc_debug_file;
            fflush (gc_debug_file.84);
            <D.21189>:
            <D.21187>:
            D.21194 = sgen_ptr_in_nursery (__copy);
            if (D.21194 != 0) goto <D.21195>; else goto <D.21192>;
            <D.21195>:
            D.21196 = sgen_ptr_in_nursery (p);
            if (D.21196 == 0) goto <D.21197>; else goto <D.21192>;
            <D.21197>:
            iftmp.98 = 1;
            goto <D.21193>;
            <D.21192>:
            iftmp.98 = 0;
            <D.21193>:
            D.21198 = iftmp.98 != 0;
            D.21199 = (long int) D.21198;
            D.21200 = __builtin_expect (D.21199, 0);
            if (D.21200 != 0) goto <D.21201>; else goto <D.21202>;
            <D.21201>:
            sgen_add_to_global_remset (p, __copy);
            <D.21202>:
            goto <D.21203>;
            <D.21185>:
            if (0 != 0) goto <D.21204>; else goto <D.21205>;
            <D.21204>:
            sgen_add_to_global_remset (p, __old);
            <D.21205>:
            <D.21203>:
          }
          <D.21183>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.19398>:
          if (_bmap != 0) goto <D.19397>; else goto <D.19399>;
          <D.19399>:
          el_size.97 = (sizetype) el_size;
          e_start = e_start + el_size.97;
        }
        <D.19401>:
        if (e_start < e_end) goto <D.19400>; else goto <D.19402>;
        <D.19402>:
      }
      <D.21180>:
      <D.21178>:
      <D.21144>:
    }
    <D.21113>:
    goto <D.19354>;
    <D.19403>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.19409>;
      <D.19408>:
      D.21206 = _bmap & 1;
      if (D.21206 != 0) goto <D.21207>; else goto <D.21208>;
      <D.21207>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21209>; else goto <D.21210>;
        <D.21209>:
        __builtin_prefetch (__old);
        major_copy_or_mark_object (_objptr, __old, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21211>; else goto <D.21212>;
        <D.21211>:
        if (__old != __copy) goto <D.21213>; else goto <D.21214>;
        <D.21213>:
        D.21215 = *_objptr;
        gc_debug_file.84 = gc_debug_file;
        fprintf (gc_debug_file.84, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21215, __old);
        gc_debug_file.84 = gc_debug_file;
        fflush (gc_debug_file.84);
        <D.21214>:
        <D.21212>:
        D.21219 = sgen_ptr_in_nursery (__copy);
        if (D.21219 != 0) goto <D.21220>; else goto <D.21217>;
        <D.21220>:
        D.21221 = sgen_ptr_in_nursery (_objptr);
        if (D.21221 == 0) goto <D.21222>; else goto <D.21217>;
        <D.21222>:
        iftmp.99 = 1;
        goto <D.21218>;
        <D.21217>:
        iftmp.99 = 0;
        <D.21218>:
        D.21223 = iftmp.99 != 0;
        D.21224 = (long int) D.21223;
        D.21225 = __builtin_expect (D.21224, 0);
        if (D.21225 != 0) goto <D.21226>; else goto <D.21227>;
        <D.21226>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21227>:
        goto <D.21228>;
        <D.21210>:
        if (0 != 0) goto <D.21229>; else goto <D.21230>;
        <D.21229>:
        sgen_add_to_global_remset (_objptr, __old);
        <D.21230>:
        <D.21228>:
      }
      <D.21208>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.19409>:
      if (_bmap != 0) goto <D.19408>; else goto <D.19410>;
      <D.19410>:
    }
    goto <D.19354>;
    <D.19411>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.21231 = *bitmap_data;
      D.21232 = D.21231 + 4294967295;
      bwords = (int) D.21232;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.21233>; else goto <D.21234>;
      <D.21233>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.21235 = myobj->vtable;
        D.21236 = D.21235->klass;
        D.21237 = D.21236->name;
        D.21235 = myobj->vtable;
        D.21236 = D.21235->klass;
        D.21238 = D.21236->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21238, D.21237);
      }
      <D.21234>:
      goto <D.19424>;
      <D.19423>:
      {
        gsize _bmap;

        bitmap_data.100 = bitmap_data;
        bitmap_data = bitmap_data.100 + 4;
        _bmap = *bitmap_data.100;
        _objptr = start_run;
        goto <D.19421>;
        <D.19420>:
        D.21240 = _bmap & 1;
        if (D.21240 != 0) goto <D.21241>; else goto <D.21242>;
        <D.21241>:
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21243>; else goto <D.21244>;
          <D.21243>:
          __builtin_prefetch (__old);
          major_copy_or_mark_object (_objptr, __old, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21245>; else goto <D.21246>;
          <D.21245>:
          if (__old != __copy) goto <D.21247>; else goto <D.21248>;
          <D.21247>:
          D.21249 = *_objptr;
          gc_debug_file.84 = gc_debug_file;
          fprintf (gc_debug_file.84, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21249, __old);
          gc_debug_file.84 = gc_debug_file;
          fflush (gc_debug_file.84);
          <D.21248>:
          <D.21246>:
          D.21253 = sgen_ptr_in_nursery (__copy);
          if (D.21253 != 0) goto <D.21254>; else goto <D.21251>;
          <D.21254>:
          D.21255 = sgen_ptr_in_nursery (_objptr);
          if (D.21255 == 0) goto <D.21256>; else goto <D.21251>;
          <D.21256>:
          iftmp.101 = 1;
          goto <D.21252>;
          <D.21251>:
          iftmp.101 = 0;
          <D.21252>:
          D.21257 = iftmp.101 != 0;
          D.21258 = (long int) D.21257;
          D.21259 = __builtin_expect (D.21258, 0);
          if (D.21259 != 0) goto <D.21260>; else goto <D.21261>;
          <D.21260>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21261>:
          goto <D.21262>;
          <D.21244>:
          if (0 != 0) goto <D.21263>; else goto <D.21264>;
          <D.21263>:
          sgen_add_to_global_remset (_objptr, __old);
          <D.21264>:
          <D.21262>:
        }
        <D.21242>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.19421>:
        if (_bmap != 0) goto <D.19420>; else goto <D.19422>;
        <D.19422>:
        start_run = start_run + 128;
      }
      <D.19424>:
      bwords.102 = bwords;
      bwords = bwords.102 + -1;
      if (bwords.102 > 0) goto <D.19423>; else goto <D.19425>;
      <D.19425>:
    }
    goto <D.19354>;
    <D.19426>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.21266 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.21266);
      mbitmap_data.103 = mbitmap_data;
      mbitmap_data = mbitmap_data.103 + 4;
      D.21268 = *mbitmap_data.103;
      D.21269 = D.21268 + 4294967295;
      mbwords = (int) D.21269;
      D.21270 = vt->klass;
      el_size = mono_array_element_size (D.21270);
      e_start = start + 16;
      D.21119 = MEM[(struct MonoArray *)start].max_length;
      el_size.104 = (unsigned int) el_size;
      D.21272 = D.21119 * el_size.104;
      e_end = e_start + D.21272;
      if (0 != 0) goto <D.21273>; else goto <D.21274>;
      <D.21273>:
      D.21270 = vt->klass;
      D.21275 = D.21270->name;
      D.21270 = vt->klass;
      D.21276 = D.21270->name_space;
      D.21266 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.21266, D.21276, D.21275);
      <D.21274>:
      goto <D.19446>;
      <D.19445>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.105 = bitmap_data;
          bitmap_data = bitmap_data.105 + 4;
          _bmap = *bitmap_data.105;
          start_run = _objptr;
          goto <D.19440>;
          <D.19439>:
          D.21278 = _bmap & 1;
          if (D.21278 != 0) goto <D.21279>; else goto <D.21280>;
          <D.21279>:
          {
            void * __old;
            void * __copy;

            __old = *_objptr;
            if (__old != 0B) goto <D.21281>; else goto <D.21282>;
            <D.21281>:
            __builtin_prefetch (__old);
            major_copy_or_mark_object (_objptr, __old, queue);
            __copy = *_objptr;
            if (0 != 0) goto <D.21283>; else goto <D.21284>;
            <D.21283>:
            if (__old != __copy) goto <D.21285>; else goto <D.21286>;
            <D.21285>:
            D.21287 = *_objptr;
            gc_debug_file.84 = gc_debug_file;
            fprintf (gc_debug_file.84, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21287, __old);
            gc_debug_file.84 = gc_debug_file;
            fflush (gc_debug_file.84);
            <D.21286>:
            <D.21284>:
            D.21291 = sgen_ptr_in_nursery (__copy);
            if (D.21291 != 0) goto <D.21292>; else goto <D.21289>;
            <D.21292>:
            D.21293 = sgen_ptr_in_nursery (_objptr);
            if (D.21293 == 0) goto <D.21294>; else goto <D.21289>;
            <D.21294>:
            iftmp.106 = 1;
            goto <D.21290>;
            <D.21289>:
            iftmp.106 = 0;
            <D.21290>:
            D.21295 = iftmp.106 != 0;
            D.21296 = (long int) D.21295;
            D.21297 = __builtin_expect (D.21296, 0);
            if (D.21297 != 0) goto <D.21298>; else goto <D.21299>;
            <D.21298>:
            sgen_add_to_global_remset (_objptr, __copy);
            <D.21299>:
            goto <D.21300>;
            <D.21282>:
            if (0 != 0) goto <D.21301>; else goto <D.21302>;
            <D.21301>:
            sgen_add_to_global_remset (_objptr, __old);
            <D.21302>:
            <D.21300>:
          }
          <D.21280>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.19440>:
          if (_bmap != 0) goto <D.19439>; else goto <D.19441>;
          <D.19441>:
          _objptr = start_run + 128;
        }
        <D.19443>:
        bwords.107 = bwords;
        bwords = bwords.107 + 4294967295;
        if (bwords.107 != 0) goto <D.19442>; else goto <D.19444>;
        <D.19444>:
        el_size.108 = (sizetype) el_size;
        e_start = e_start + el_size.108;
      }
      <D.19446>:
      if (e_start < e_end) goto <D.19445>; else goto <D.19447>;
      <D.19447>:
    }
    goto <D.19354>;
    <D.19448>:
    goto <D.19354>;
    <D.19449>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.19354>:
  }
}


major_copy_or_mark_object (void * * ptr, void * obj, struct SgenGrayQueue * queue)
{
  int current_collection_generation.109;
  int D.21311;
  char * iftmp.110;
  unsigned int D.21315;
  unsigned int D.21316;
  unsigned int D.21319;
  unsigned int D.21323;
  int D.21326;
  _Bool D.21329;
  long int D.21330;
  long int D.21331;
  int D.21334;
  unsigned int obj.111;
  unsigned int D.21338;
  struct MSBlockHeader * D.21339;
  gboolean * evacuate_block_obj_sizes.112;
  unsigned int size_index.113;
  unsigned int D.21342;
  gboolean * D.21343;
  int obj.114;
  int obj.115;
  int D.21346;
  int D.21347;
  unsigned int D.21353;
  long int D.21354;
  long unsigned int D.21355;
  long unsigned int D.21356;
  long unsigned int D.21359;
  unsigned char D.21360;
  unsigned char D.21361;
  int iftmp.116;
  struct GrayQueueSection * D.21368;
  int D.21370;
  _Bool D.21371;
  long int D.21372;
  long int D.21373;
  int D.21377;
  int D.21378;
  int D.21379;
  unsigned int D.21387;
  long int D.21388;
  long unsigned int D.21389;
  long unsigned int D.21390;
  char * iftmp.117;
  unsigned int D.21398;
  unsigned int D.21399;
  unsigned int size_index.118;
  unsigned int D.21403;
  gboolean * D.21404;
  unsigned char D.21407;
  _Bool D.21409;
  long int D.21410;
  long int D.21411;
  unsigned char D.21414;
  unsigned int D.21422;
  long int D.21423;
  long unsigned int D.21424;
  long unsigned int D.21425;
  long unsigned int D.21428;
  int iftmp.119;
  _Bool D.21436;
  long int D.21437;
  long int D.21438;
  int D.21442;
  int D.21443;
  int D.21445;
  struct MonoVTable * D.21448;
  void * D.21449;
  unsigned int D.21450;
  int D.21451;
  int iftmp.120;
  _Bool D.21459;
  long int D.21460;
  long int D.21461;
  int D.21465;
  int D.21466;
  struct MSBlockInfo * block;
  void do_copy_object = <<< error >>>;

  if (0 != 0) goto <D.21306>; else goto <D.21307>;
  <D.21306>:
  monoeg_g_log (0B, 4, "null object from pointer %p", ptr);
  <D.19304>:
  goto <D.19304>;
  <D.21307>:
  if (0 != 0) goto <D.21308>; else goto <D.21309>;
  <D.21308>:
  current_collection_generation.109 = current_collection_generation;
  monoeg_g_log (0B, 4, "old gen parallel allocator called from a %d collection", current_collection_generation.109);
  <D.19305>:
  goto <D.19305>;
  <D.21309>:
  D.21311 = sgen_ptr_in_nursery (obj);
  if (D.21311 != 0) goto <D.21312>; else goto <D.21313>;
  <D.21312>:
  {
    int word;
    int bit;
    char * forwarded;
    char * old_obj;

    D.21315 = MEM[(mword *)obj];
    D.21316 = D.21315 & 1;
    if (D.21316 != 0) goto <D.21317>; else goto <D.21318>;
    <D.21317>:
    D.21315 = MEM[(mword *)obj];
    D.21319 = D.21315 & 4294967292;
    iftmp.110 = (char *) D.21319;
    goto <D.21320>;
    <D.21318>:
    iftmp.110 = 0B;
    <D.21320>:
    forwarded = iftmp.110;
    if (forwarded != 0B) goto <D.21321>; else goto <D.21322>;
    <D.21321>:
    *ptr = forwarded;
    return;
    <D.21322>:
    D.21315 = MEM[(mword *)obj];
    D.21323 = D.21315 & 2;
    if (D.21323 != 0) goto <D.21324>; else goto <D.21325>;
    <D.21324>:
    return;
    <D.21325>:
    D.21326 = sgen_nursery_is_to_space (obj);
    if (D.21326 != 0) goto <D.21327>; else goto <D.21328>;
    <D.21327>:
    return;
    <D.21328>:
    do_copy_object:
    old_obj = obj;
    obj = copy_object_no_checks (obj, queue);
    D.21329 = old_obj == obj;
    D.21330 = (long int) D.21329;
    D.21331 = __builtin_expect (D.21330, 0);
    if (D.21331 != 0) goto <D.21332>; else goto <D.21333>;
    <D.21332>:
    D.21334 = sgen_ptr_in_nursery (obj);
    if (D.21334 == 0) goto <D.21335>; else goto <D.21336>;
    <D.21335>:
    {
      int size_index;

      obj.111 = (unsigned int) obj;
      D.21338 = obj.111 & 4294950912;
      D.21339 = (struct MSBlockHeader *) D.21338;
      block = D.21339->info;
      size_index = block->obj_size_index;
      evacuate_block_obj_sizes.112 = evacuate_block_obj_sizes;
      size_index.113 = (unsigned int) size_index;
      D.21342 = size_index.113 * 4;
      D.21343 = evacuate_block_obj_sizes.112 + D.21342;
      *D.21343 = 0;
      {
        int __word;
        int __bit;

        {
          int i;

          obj.114 = (int) obj;
          obj.115 = (int) obj;
          D.21346 = obj.115 & -16384;
          D.21347 = obj.114 - D.21346;
          i = D.21347 >> 3;
          if (1 != 0) goto <D.21348>; else goto <D.21349>;
          <D.21348>:
          __word = i >> 5;
          __bit = i & 31;
          goto <D.21350>;
          <D.21349>:
          __word = i >> 6;
          __bit = i & 63;
          <D.21350>:
        }
        if (0 != 0) goto <D.21351>; else goto <D.21352>;
        <D.21351>:
        monoeg_g_log (0B, 4, "object %p not allocated", obj);
        <D.19315>:
        goto <D.19315>;
        <D.21352>:
        D.21353 = block->mark_words[__word];
        D.21354 = 1 << __bit;
        D.21355 = (long unsigned int) D.21354;
        D.21356 = D.21353 & D.21355;
        if (D.21356 == 0) goto <D.21357>; else goto <D.21358>;
        <D.21357>:
        D.21353 = block->mark_words[__word];
        D.21354 = 1 << __bit;
        D.21355 = (long unsigned int) D.21354;
        D.21359 = D.21353 | D.21355;
        block->mark_words[__word] = D.21359;
        D.21360 = BIT_FIELD_REF <*block, 8, 96>;
        D.21361 = D.21360 & 2;
        if (D.21361 != 0) goto <D.21362>; else goto <D.21363>;
        <D.21362>:
        D.21368 = queue->first;
        if (D.21368 == 0B) goto <D.21365>; else goto <D.21369>;
        <D.21369>:
        D.21368 = queue->first;
        D.21370 = D.21368->end;
        if (D.21370 == 125) goto <D.21365>; else goto <D.21366>;
        <D.21365>:
        iftmp.116 = 1;
        goto <D.21367>;
        <D.21366>:
        iftmp.116 = 0;
        <D.21367>:
        D.21371 = iftmp.116 != 0;
        D.21372 = (long int) D.21371;
        D.21373 = __builtin_expect (D.21372, 0);
        if (D.21373 != 0) goto <D.21374>; else goto <D.21375>;
        <D.21374>:
        sgen_gray_object_enqueue (queue, obj);
        goto <D.21376>;
        <D.21375>:
        D.21368 = queue->first;
        D.21368 = queue->first;
        D.21370 = D.21368->end;
        D.21377 = D.21370;
        D.21378 = D.21377 + 1;
        D.21368->end = D.21378;
        D.21368->objects[D.21377] = obj;
        <D.21376>:
        __builtin_prefetch (obj);
        <D.21363>:
        <D.21358>:
      }
    }
    <D.21336>:
    return;
    <D.21333>:
    *ptr = obj;
    D.21379 = sgen_ptr_in_nursery (obj);
    if (D.21379 == 0) goto <D.21380>; else goto <D.21381>;
    <D.21380>:
    obj.111 = (unsigned int) obj;
    D.21338 = obj.111 & 4294950912;
    D.21339 = (struct MSBlockHeader *) D.21338;
    block = D.21339->info;
    {
      int i;

      obj.114 = (int) obj;
      obj.115 = (int) obj;
      D.21346 = obj.115 & -16384;
      D.21347 = obj.114 - D.21346;
      i = D.21347 >> 3;
      if (1 != 0) goto <D.21382>; else goto <D.21383>;
      <D.21382>:
      word = i >> 5;
      bit = i & 31;
      goto <D.21384>;
      <D.21383>:
      word = i >> 6;
      bit = i & 63;
      <D.21384>:
    }
    if (0 != 0) goto <D.21385>; else goto <D.21386>;
    <D.21385>:
    monoeg_g_log (0B, 4, "object %p already marked", obj);
    <D.19317>:
    goto <D.19317>;
    <D.21386>:
    D.21387 = block->mark_words[word];
    D.21388 = 1 << bit;
    D.21389 = (long unsigned int) D.21388;
    D.21390 = D.21387 | D.21389;
    block->mark_words[word] = D.21390;
    <D.21381>:
  }
  goto <D.21391>;
  <D.21313>:
  {
    char * forwarded;
    mword objsize;

    D.21315 = MEM[(mword *)obj];
    D.21316 = D.21315 & 1;
    if (D.21316 != 0) goto <D.21393>; else goto <D.21394>;
    <D.21393>:
    D.21315 = MEM[(mword *)obj];
    D.21319 = D.21315 & 4294967292;
    iftmp.117 = (char *) D.21319;
    goto <D.21395>;
    <D.21394>:
    iftmp.117 = 0B;
    <D.21395>:
    forwarded = iftmp.117;
    if (forwarded != 0B) goto <D.21396>; else goto <D.21397>;
    <D.21396>:
    *ptr = forwarded;
    return;
    <D.21397>:
    D.21398 = sgen_safe_object_get_size (obj);
    D.21399 = D.21398 + 7;
    objsize = D.21399 & 4294967288;
    if (objsize <= 8000) goto <D.21400>; else goto <D.21401>;
    <D.21400>:
    {
      int size_index;
      gboolean evacuate;

      obj.111 = (unsigned int) obj;
      D.21338 = obj.111 & 4294950912;
      D.21339 = (struct MSBlockHeader *) D.21338;
      block = D.21339->info;
      size_index = block->obj_size_index;
      evacuate_block_obj_sizes.112 = evacuate_block_obj_sizes;
      size_index.118 = (unsigned int) size_index;
      D.21403 = size_index.118 * 4;
      D.21404 = evacuate_block_obj_sizes.112 + D.21403;
      evacuate = *D.21404;
      if (evacuate != 0) goto <D.21406>; else goto <D.21405>;
      <D.21406>:
      D.21360 = BIT_FIELD_REF <*block, 8, 96>;
      D.21407 = D.21360 & 4;
      if (D.21407 == 0) goto <D.21408>; else goto <D.21405>;
      <D.21408>:
      D.21315 = MEM[(mword *)obj];
      D.21323 = D.21315 & 2;
      D.21409 = D.21323 != 0;
      D.21410 = (long int) D.21409;
      D.21411 = __builtin_expect (D.21410, 0);
      if (D.21411 != 0) goto <D.21412>; else goto <D.21413>;
      <D.21412>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 1425, "!SGEN_OBJECT_IS_PINNED (obj)");
      <D.21413>:
      D.21360 = BIT_FIELD_REF <*block, 8, 96>;
      D.21414 = D.21360 & 8;
      if (D.21414 != 0) goto <D.21415>; else goto <D.21416>;
      <D.21415>:
      return;
      <D.21416>:
      goto do_copy_object;
      <D.21405>:
      {
        int __word;
        int __bit;

        {
          int i;

          obj.114 = (int) obj;
          obj.115 = (int) obj;
          D.21346 = obj.115 & -16384;
          D.21347 = obj.114 - D.21346;
          i = D.21347 >> 3;
          if (1 != 0) goto <D.21417>; else goto <D.21418>;
          <D.21417>:
          __word = i >> 5;
          __bit = i & 31;
          goto <D.21419>;
          <D.21418>:
          __word = i >> 6;
          __bit = i & 63;
          <D.21419>:
        }
        if (0 != 0) goto <D.21420>; else goto <D.21421>;
        <D.21420>:
        monoeg_g_log (0B, 4, "object %p not allocated", obj);
        <D.19325>:
        goto <D.19325>;
        <D.21421>:
        D.21422 = block->mark_words[__word];
        D.21423 = 1 << __bit;
        D.21424 = (long unsigned int) D.21423;
        D.21425 = D.21422 & D.21424;
        if (D.21425 == 0) goto <D.21426>; else goto <D.21427>;
        <D.21426>:
        D.21422 = block->mark_words[__word];
        D.21423 = 1 << __bit;
        D.21424 = (long unsigned int) D.21423;
        D.21428 = D.21422 | D.21424;
        block->mark_words[__word] = D.21428;
        D.21360 = BIT_FIELD_REF <*block, 8, 96>;
        D.21361 = D.21360 & 2;
        if (D.21361 != 0) goto <D.21429>; else goto <D.21430>;
        <D.21429>:
        D.21368 = queue->first;
        if (D.21368 == 0B) goto <D.21432>; else goto <D.21435>;
        <D.21435>:
        D.21368 = queue->first;
        D.21370 = D.21368->end;
        if (D.21370 == 125) goto <D.21432>; else goto <D.21433>;
        <D.21432>:
        iftmp.119 = 1;
        goto <D.21434>;
        <D.21433>:
        iftmp.119 = 0;
        <D.21434>:
        D.21436 = iftmp.119 != 0;
        D.21437 = (long int) D.21436;
        D.21438 = __builtin_expect (D.21437, 0);
        if (D.21438 != 0) goto <D.21439>; else goto <D.21440>;
        <D.21439>:
        sgen_gray_object_enqueue (queue, obj);
        goto <D.21441>;
        <D.21440>:
        D.21368 = queue->first;
        D.21368 = queue->first;
        D.21370 = D.21368->end;
        D.21442 = D.21370;
        D.21443 = D.21442 + 1;
        D.21368->end = D.21443;
        D.21368->objects[D.21442] = obj;
        <D.21441>:
        __builtin_prefetch (obj);
        <D.21430>:
        <D.21427>:
      }
    }
    goto <D.21444>;
    <D.21401>:
    D.21445 = sgen_los_object_is_pinned (obj);
    if (D.21445 != 0) goto <D.21446>; else goto <D.21447>;
    <D.21446>:
    return;
    <D.21447>:
    sgen_los_pin_object (obj);
    D.21315 = MEM[(mword *)obj];
    D.21319 = D.21315 & 4294967292;
    D.21448 = (struct MonoVTable *) D.21319;
    D.21449 = D.21448->gc_descr;
    D.21450 = (unsigned int) D.21449;
    D.21451 = sgen_gc_descr_has_references (D.21450);
    if (D.21451 != 0) goto <D.21452>; else goto <D.21453>;
    <D.21452>:
    D.21368 = queue->first;
    if (D.21368 == 0B) goto <D.21455>; else goto <D.21458>;
    <D.21458>:
    D.21368 = queue->first;
    D.21370 = D.21368->end;
    if (D.21370 == 125) goto <D.21455>; else goto <D.21456>;
    <D.21455>:
    iftmp.120 = 1;
    goto <D.21457>;
    <D.21456>:
    iftmp.120 = 0;
    <D.21457>:
    D.21459 = iftmp.120 != 0;
    D.21460 = (long int) D.21459;
    D.21461 = __builtin_expect (D.21460, 0);
    if (D.21461 != 0) goto <D.21462>; else goto <D.21463>;
    <D.21462>:
    sgen_gray_object_enqueue (queue, obj);
    goto <D.21464>;
    <D.21463>:
    D.21368 = queue->first;
    D.21368 = queue->first;
    D.21370 = D.21368->end;
    D.21465 = D.21370;
    D.21466 = D.21465 + 1;
    D.21368->end = D.21466;
    D.21368->objects[D.21465] = obj;
    <D.21464>:
    __builtin_prefetch (obj);
    <D.21453>:
    <D.21444>:
  }
  <D.21391>:
}


sgen_nursery_is_to_space (char * object)
{
  int object.121;
  char * sgen_nursery_start.122;
  int sgen_nursery_start.123;
  int D.21471;
  int D.21472;
  _Bool D.21473;
  long int D.21474;
  long int D.21475;
  char * D.21478;
  char * D.21479;
  int sgen_space_bitmap_size.124;
  _Bool D.21481;
  long int D.21482;
  long int D.21483;
  gboolean D.21486;
  char * sgen_space_bitmap.125;
  sizetype byte.126;
  char * D.21489;
  char D.21490;
  int D.21491;
  int D.21492;
  int D.21493;
  _Bool D.21494;
  int idx;
  int byte;
  int bit;

  object.121 = (int) object;
  sgen_nursery_start.122 = sgen_nursery_start;
  sgen_nursery_start.123 = (int) sgen_nursery_start.122;
  D.21471 = object.121 - sgen_nursery_start.123;
  idx = D.21471 >> 9;
  byte = idx / 8;
  bit = idx & 7;
  D.21472 = sgen_ptr_in_nursery (object);
  D.21473 = D.21472 == 0;
  D.21474 = (long int) D.21473;
  D.21475 = __builtin_expect (D.21474, 0);
  if (D.21475 != 0) goto <D.21476>; else goto <D.21477>;
  <D.21476>:
  D.21478 = sgen_get_nursery_end ();
  D.21479 = sgen_get_nursery_start ();
  monoeg_g_log (0B, 4, "object %p is not in nursery [%p - %p]", object, D.21479, D.21478);
  <D.18355>:
  goto <D.18355>;
  <D.21477>:
  sgen_space_bitmap_size.124 = sgen_space_bitmap_size;
  D.21481 = byte >= sgen_space_bitmap_size.124;
  D.21482 = (long int) D.21481;
  D.21483 = __builtin_expect (D.21482, 0);
  if (D.21483 != 0) goto <D.21484>; else goto <D.21485>;
  <D.21484>:
  sgen_space_bitmap_size.124 = sgen_space_bitmap_size;
  monoeg_g_log (0B, 4, "byte index %d out of range", byte, sgen_space_bitmap_size.124);
  <D.18356>:
  goto <D.18356>;
  <D.21485>:
  sgen_space_bitmap.125 = sgen_space_bitmap;
  byte.126 = (sizetype) byte;
  D.21489 = sgen_space_bitmap.125 + byte.126;
  D.21490 = *D.21489;
  D.21491 = (int) D.21490;
  D.21492 = D.21491 >> bit;
  D.21493 = D.21492 & 1;
  D.21494 = D.21493 != 0;
  D.21486 = (gboolean) D.21494;
  return D.21486;
}


sgen_get_nursery_end ()
{
  char * D.21496;

  D.21496 = sgen_nursery_end;
  return D.21496;
}


sgen_get_nursery_start ()
{
  char * D.21498;

  D.21498 = sgen_nursery_start;
  return D.21498;
}


copy_object_no_checks (void * obj, struct SgenGrayQueue * queue)
{
  void * D.21500;
  unsigned int D.21501;
  unsigned int D.21502;
  unsigned int D.21503;
  char * (*<T3051>) (struct MonoVTable *, char *, size_t, gboolean) D.21504;
  _Bool D.21505;
  long int D.21506;
  long int D.21507;
  int D.21510;
  _Bool D.21514;
  long int D.21515;
  long int D.21516;
  void * D.21519;
  struct SgenGrayQueue * iftmp.127;
  unsigned int destination.128;
  unsigned int D.21525;
  struct MonoVTable * vt;
  gboolean has_references;
  mword objsize;
  char * destination;

  vt = MEM[(struct MonoObject *)obj].vtable;
  D.21500 = vt->gc_descr;
  D.21501 = (unsigned int) D.21500;
  has_references = sgen_gc_descr_has_references (D.21501);
  D.21502 = sgen_par_object_get_size (vt, obj);
  D.21503 = D.21502 + 7;
  objsize = D.21503 & 4294967288;
  D.21504 = sgen_minor_collector.alloc_for_promotion;
  destination = D.21504 (vt, obj, objsize, has_references);
  D.21505 = destination == 0B;
  D.21506 = (long int) D.21505;
  D.21507 = __builtin_expect (D.21506, 0);
  if (D.21507 != 0) goto <D.21508>; else goto <D.21509>;
  <D.21508>:
  D.21510 = sgen_ptr_in_nursery (obj);
  if (D.21510 != 0) goto <D.21511>; else goto <D.21512>;
  <D.21511>:
  sgen_pin_object (obj, queue);
  goto <D.21513>;
  <D.21512>:
  D.21514 = objsize > 8000;
  D.21515 = (long int) D.21514;
  D.21516 = __builtin_expect (D.21515, 0);
  if (D.21516 != 0) goto <D.21517>; else goto <D.21518>;
  <D.21517>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-copy-object.h", 115, "objsize <= SGEN_MAX_SMALL_OBJ_SIZE");
  <D.21518>:
  pin_major_object (obj, queue);
  <D.21513>:
  sgen_set_pinned_from_failed_allocation (objsize);
  D.21519 = obj;
  return D.21519;
  <D.21509>:
  if (has_references != 0) goto <D.21521>; else goto <D.21522>;
  <D.21521>:
  iftmp.127 = queue;
  goto <D.21523>;
  <D.21522>:
  iftmp.127 = 0B;
  <D.21523>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.127);
  destination.128 = (unsigned int) destination;
  D.21525 = destination.128 | 1;
  MEM[(mword *)obj] = D.21525;
  D.21519 = destination;
  return D.21519;
}


par_copy_object_no_checks (char * destination, struct MonoVTable * vt, void * obj, mword objsize, struct SgenGrayQueue * queue)
{
  struct MonoClass * D.21529;
  const char * D.21530;
  const char * D.21531;
  struct MonoVTable * D.21534;
  struct MonoClass * D.21535;
  const char * D.21536;
  struct FILE * gc_debug_file.129;
  unsigned int D.21540;
  const void * D.21541;
  mword * D.21542;
  unsigned int D.21543;
  mword * D.21544;
  unsigned int D.21545;
  mword * D.21546;
  unsigned int D.21547;
  mword * D.21548;
  unsigned int D.21549;
  mword * D.21550;
  unsigned int D.21551;
  mword * D.21552;
  unsigned int D.21553;
  mword * D.21554;
  unsigned int D.21555;
  unsigned int D.21557;
  const void * D.21558;
  void * D.21559;
  int iftmp.130;
  unsigned char D.21565;
  struct MonoArrayBounds * D.21567;
  _Bool D.21569;
  long int D.21570;
  long int D.21571;
  int D.21574;
  int obj.131;
  int D.21576;
  sizetype D.21577;
  struct MonoArrayBounds * D.21578;
  unsigned int D.21581;
  int D.21582;
  <unnamed type> mono_profiler_events.132;
  unsigned int D.21584;
  _Bool D.21585;
  long int D.21586;
  long int D.21587;
  const char * D.21594;
  int iftmp.133;
  struct GrayQueueSection * D.21599;
  int D.21601;
  _Bool D.21602;
  long int D.21603;
  long int D.21604;
  int D.21608;
  int D.21609;
  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.21527>; else goto <D.21528>;
  <D.21527>:
  D.21529 = vt->klass;
  D.21530 = D.21529->name;
  D.21529 = vt->klass;
  D.21531 = D.21529->name_space;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s was not initialized", vt, D.21531, D.21530);
  <D.19275>:
  goto <D.19275>;
  <D.21528>:
  if (0 != 0) goto <D.21532>; else goto <D.21533>;
  <D.21532>:
  D.21534 = MEM[(struct MonoObject *)obj].vtable;
  D.21535 = D.21534->klass;
  D.21536 = D.21535->name;
  gc_debug_file.129 = gc_debug_file;
  fprintf (gc_debug_file.129, " (to %p, %s size: %lu)\n", destination, D.21536, objsize);
  gc_debug_file.129 = gc_debug_file;
  fflush (gc_debug_file.129);
  <D.21533>:
  if (objsize <= 32) goto <D.21538>; else goto <D.21539>;
  <D.21538>:
  {
    mword * dest;

    dest = destination;
    D.21540 = objsize / 4;
    D.21541 = copy_labels[D.21540];
    goto D.21541;
    LAB_8:
    D.21542 = dest + 28;
    D.21543 = MEM[(mword *)obj + 28B];
    *D.21542 = D.21543;
    LAB_7:
    D.21544 = dest + 24;
    D.21545 = MEM[(mword *)obj + 24B];
    *D.21544 = D.21545;
    LAB_6:
    D.21546 = dest + 20;
    D.21547 = MEM[(mword *)obj + 20B];
    *D.21546 = D.21547;
    LAB_5:
    D.21548 = dest + 16;
    D.21549 = MEM[(mword *)obj + 16B];
    *D.21548 = D.21549;
    LAB_4:
    D.21550 = dest + 12;
    D.21551 = MEM[(mword *)obj + 12B];
    *D.21550 = D.21551;
    LAB_3:
    D.21552 = dest + 8;
    D.21553 = MEM[(mword *)obj + 8B];
    *D.21552 = D.21553;
    LAB_2:
    D.21554 = dest + 4;
    D.21555 = MEM[(mword *)obj + 4B];
    *D.21554 = D.21555;
    LAB_1:
    LAB_0:
  }
  goto <D.21556>;
  <D.21539>:
  D.21557 = objsize + 4294967292;
  D.21558 = obj + 4;
  D.21559 = destination + 4;
  mono_gc_memmove_aligned (D.21559, D.21558, D.21557);
  <D.21556>:
  if (0 != 0) goto <D.21560>; else goto <D.21561>;
  <D.21560>:
  D.21529 = vt->klass;
  D.21530 = D.21529->name;
  D.21529 = vt->klass;
  D.21531 = D.21529->name_space;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s has no gc descriptor", vt, D.21531, D.21530);
  <D.19277>:
  goto <D.19277>;
  <D.21561>:
  D.21565 = vt->rank;
  if (D.21565 != 0) goto <D.21566>; else goto <D.21563>;
  <D.21566>:
  D.21567 = MEM[(struct MonoArray *)obj].bounds;
  if (D.21567 != 0B) goto <D.21568>; else goto <D.21563>;
  <D.21568>:
  iftmp.130 = 1;
  goto <D.21564>;
  <D.21563>:
  iftmp.130 = 0;
  <D.21564>:
  D.21569 = iftmp.130 != 0;
  D.21570 = (long int) D.21569;
  D.21571 = __builtin_expect (D.21570, 0);
  if (D.21571 != 0) goto <D.21572>; else goto <D.21573>;
  <D.21572>:
  {
    struct MonoArray * array;

    array = destination;
    D.21567 = MEM[(struct MonoArray *)obj].bounds;
    D.21574 = (int) D.21567;
    obj.131 = (int) obj;
    D.21576 = D.21574 - obj.131;
    D.21577 = (sizetype) D.21576;
    D.21578 = destination + D.21577;
    array->bounds = D.21578;
    if (0 != 0) goto <D.21579>; else goto <D.21580>;
    <D.21579>:
    D.21581 = mono_array_length (array);
    D.21565 = vt->rank;
    D.21582 = (int) D.21565;
    gc_debug_file.129 = gc_debug_file;
    fprintf (gc_debug_file.129, "Array instance %p: size: %lu, rank: %d, length: %lu\n", array, objsize, D.21582, D.21581);
    gc_debug_file.129 = gc_debug_file;
    fflush (gc_debug_file.129);
    <D.21580>:
  }
  <D.21573>:
  mono_profiler_events.132 = mono_profiler_events;
  D.21584 = mono_profiler_events.132 & 524288;
  D.21585 = D.21584 != 0;
  D.21586 = (long int) D.21585;
  D.21587 = __builtin_expect (D.21586, 0);
  if (D.21587 != 0) goto <D.21588>; else goto <D.21589>;
  <D.21588>:
  sgen_register_moved_object (obj, destination);
  <D.21589>:
  obj = destination;
  if (queue != 0B) goto <D.21590>; else goto <D.21591>;
  <D.21590>:
  if (0 != 0) goto <D.21592>; else goto <D.21593>;
  <D.21592>:
  D.21594 = sgen_safe_name (obj);
  gc_debug_file.129 = gc_debug_file;
  fprintf (gc_debug_file.129, "Enqueuing gray object %p (%s)\n", obj, D.21594);
  gc_debug_file.129 = gc_debug_file;
  fflush (gc_debug_file.129);
  <D.21593>:
  D.21599 = queue->first;
  if (D.21599 == 0B) goto <D.21596>; else goto <D.21600>;
  <D.21600>:
  D.21599 = queue->first;
  D.21601 = D.21599->end;
  if (D.21601 == 125) goto <D.21596>; else goto <D.21597>;
  <D.21596>:
  iftmp.133 = 1;
  goto <D.21598>;
  <D.21597>:
  iftmp.133 = 0;
  <D.21598>:
  D.21602 = iftmp.133 != 0;
  D.21603 = (long int) D.21602;
  D.21604 = __builtin_expect (D.21603, 0);
  if (D.21604 != 0) goto <D.21605>; else goto <D.21606>;
  <D.21605>:
  sgen_gray_object_enqueue (queue, obj);
  goto <D.21607>;
  <D.21606>:
  D.21599 = queue->first;
  D.21599 = queue->first;
  D.21601 = D.21599->end;
  D.21608 = D.21601;
  D.21609 = D.21608 + 1;
  D.21599->end = D.21609;
  D.21599->objects[D.21608] = obj;
  <D.21607>:
  __builtin_prefetch (obj);
  <D.21591>:
}


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

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


major_describe_pointer (char * ptr)
{
  char * D.21615;
  char * D.21617;
  int gc_debug_level.135;
  _Bool D.21619;
  long int D.21620;
  long int D.21621;
  <unnamed-unsigned:1> D.21624;
  int D.21625;
  <unnamed-unsigned:1> D.21626;
  int D.21627;
  int D.21628;
  struct FILE * gc_debug_file.136;
  int ptr.137;
  char * D.21631;
  int D.21632;
  int D.21633;
  int D.21634;
  sizetype D.21635;
  sizetype D.21636;
  int iftmp.138;
  void * D.21641;
  char * D.21643;
  struct MonoVTable * iftmp.139;
  unsigned int D.21648;
  unsigned int D.21649;
  int obj.140;
  int obj.141;
  int D.21653;
  int D.21654;
  unsigned int D.21658;
  long int D.21659;
  long unsigned int D.21660;
  long unsigned int D.21661;
  int D.21678;
  _Bool D.21684;
  int D.21685;
  struct MonoVTable * D.21686;
  struct MSBlockInfo * block;

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

    D.21615 = block->block;
    if (D.21615 > ptr) goto <D.21613>; else goto <D.21616>;
    <D.21616>:
    D.21615 = block->block;
    D.21617 = D.21615 + 16384;
    if (D.21617 <= ptr) goto <D.21613>; else goto <D.21614>;
    <D.21613>:
    // predicted unlikely by continue predictor.
    goto <D.19205>;
    <D.21614>:
    gc_debug_level.135 = gc_debug_level;
    D.21619 = gc_debug_level.135 >= 0;
    D.21620 = (long int) D.21619;
    D.21621 = __builtin_expect (D.21620, 0);
    if (D.21621 != 0) goto <D.21622>; else goto <D.21623>;
    <D.21622>:
    D.21624 = block->has_references;
    D.21625 = (int) D.21624;
    D.21626 = block->pinned;
    D.21627 = (int) D.21626;
    D.21628 = block->obj_size;
    D.21615 = block->block;
    gc_debug_file.136 = gc_debug_file;
    fprintf (gc_debug_file.136, "major-ptr (block %p sz %d pin %d ref %d)\n\n", D.21615, D.21628, D.21627, D.21625);
    gc_debug_file.136 = gc_debug_file;
    fflush (gc_debug_file.136);
    <D.21623>:
    ptr.137 = (int) ptr;
    D.21615 = block->block;
    D.21631 = D.21615 + 16;
    D.21632 = (int) D.21631;
    D.21633 = ptr.137 - D.21632;
    D.21628 = block->obj_size;
    idx = D.21633 / D.21628;
    D.21615 = block->block;
    D.21628 = block->obj_size;
    D.21634 = D.21628 * idx;
    D.21635 = (sizetype) D.21634;
    D.21636 = D.21635 + 16;
    obj = D.21615 + D.21636;
    D.21641 = MEM[(void * *)obj];
    if (D.21641 != 0B) goto <D.21642>; else goto <D.21638>;
    <D.21642>:
    D.21643 = MEM[(char * *)obj];
    D.21615 = block->block;
    if (D.21643 < D.21615) goto <D.21639>; else goto <D.21644>;
    <D.21644>:
    D.21643 = MEM[(char * *)obj];
    D.21615 = block->block;
    D.21617 = D.21615 + 16384;
    if (D.21643 >= D.21617) goto <D.21639>; else goto <D.21638>;
    <D.21639>:
    iftmp.138 = 1;
    goto <D.21640>;
    <D.21638>:
    iftmp.138 = 0;
    <D.21640>:
    live = iftmp.138;
    if (live != 0) goto <D.21646>; else goto <D.21647>;
    <D.21646>:
    D.21648 = MEM[(mword *)obj];
    D.21649 = D.21648 & 4294967292;
    iftmp.139 = (struct MonoVTable *) D.21649;
    goto <D.21650>;
    <D.21647>:
    iftmp.139 = 0B;
    <D.21650>:
    vtable = iftmp.139;
    {
      int i;

      obj.140 = (int) obj;
      obj.141 = (int) obj;
      D.21653 = obj.141 & -16384;
      D.21654 = obj.140 - D.21653;
      i = D.21654 >> 3;
      if (1 != 0) goto <D.21655>; else goto <D.21656>;
      <D.21655>:
      w = i >> 5;
      b = i & 31;
      goto <D.21657>;
      <D.21656>:
      w = i >> 6;
      b = i & 63;
      <D.21657>:
    }
    D.21658 = block->mark_words[w];
    D.21659 = 1 << b;
    D.21660 = (long unsigned int) D.21659;
    D.21661 = D.21658 & D.21660;
    marked = (gboolean) D.21661;
    if (obj == ptr) goto <D.21662>; else goto <D.21663>;
    <D.21662>:
    gc_debug_level.135 = gc_debug_level;
    D.21619 = gc_debug_level.135 >= 0;
    D.21620 = (long int) D.21619;
    D.21621 = __builtin_expect (D.21620, 0);
    if (D.21621 != 0) goto <D.21664>; else goto <D.21665>;
    <D.21664>:
    gc_debug_file.136 = gc_debug_file;
    fprintf (gc_debug_file.136, "\t(\n");
    gc_debug_file.136 = gc_debug_file;
    fflush (gc_debug_file.136);
    <D.21665>:
    if (live != 0) goto <D.21666>; else goto <D.21667>;
    <D.21666>:
    gc_debug_level.135 = gc_debug_level;
    D.21619 = gc_debug_level.135 >= 0;
    D.21620 = (long int) D.21619;
    D.21621 = __builtin_expect (D.21620, 0);
    if (D.21621 != 0) goto <D.21668>; else goto <D.21669>;
    <D.21668>:
    gc_debug_file.136 = gc_debug_file;
    fprintf (gc_debug_file.136, "object\n");
    gc_debug_file.136 = gc_debug_file;
    fflush (gc_debug_file.136);
    <D.21669>:
    goto <D.21670>;
    <D.21667>:
    gc_debug_level.135 = gc_debug_level;
    D.21619 = gc_debug_level.135 >= 0;
    D.21620 = (long int) D.21619;
    D.21621 = __builtin_expect (D.21620, 0);
    if (D.21621 != 0) goto <D.21671>; else goto <D.21672>;
    <D.21671>:
    gc_debug_file.136 = gc_debug_file;
    fprintf (gc_debug_file.136, "dead-object\n");
    gc_debug_file.136 = gc_debug_file;
    fflush (gc_debug_file.136);
    <D.21672>:
    <D.21670>:
    goto <D.21673>;
    <D.21663>:
    if (live != 0) goto <D.21674>; else goto <D.21675>;
    <D.21674>:
    gc_debug_level.135 = gc_debug_level;
    D.21619 = gc_debug_level.135 >= 0;
    D.21620 = (long int) D.21619;
    D.21621 = __builtin_expect (D.21620, 0);
    if (D.21621 != 0) goto <D.21676>; else goto <D.21677>;
    <D.21676>:
    ptr.137 = (int) ptr;
    obj.140 = (int) obj;
    D.21678 = ptr.137 - obj.140;
    gc_debug_file.136 = gc_debug_file;
    fprintf (gc_debug_file.136, "interior-ptr offset %td\n", D.21678);
    gc_debug_file.136 = gc_debug_file;
    fflush (gc_debug_file.136);
    <D.21677>:
    goto <D.21679>;
    <D.21675>:
    gc_debug_level.135 = gc_debug_level;
    D.21619 = gc_debug_level.135 >= 0;
    D.21620 = (long int) D.21619;
    D.21621 = __builtin_expect (D.21620, 0);
    if (D.21621 != 0) goto <D.21680>; else goto <D.21681>;
    <D.21680>:
    ptr.137 = (int) ptr;
    obj.140 = (int) obj;
    D.21678 = ptr.137 - obj.140;
    gc_debug_file.136 = gc_debug_file;
    fprintf (gc_debug_file.136, "dead-interior-ptr offset %td\n", D.21678);
    gc_debug_file.136 = gc_debug_file;
    fflush (gc_debug_file.136);
    <D.21681>:
    <D.21679>:
    <D.21673>:
    gc_debug_level.135 = gc_debug_level;
    D.21619 = gc_debug_level.135 >= 0;
    D.21620 = (long int) D.21619;
    D.21621 = __builtin_expect (D.21620, 0);
    if (D.21621 != 0) goto <D.21682>; else goto <D.21683>;
    <D.21682>:
    D.21684 = marked != 0;
    D.21685 = (int) D.21684;
    gc_debug_file.136 = gc_debug_file;
    fprintf (gc_debug_file.136, " marked %d)\n\n", D.21685);
    gc_debug_file.136 = gc_debug_file;
    fflush (gc_debug_file.136);
    <D.21683>:
    D.21686 = vtable;
    return D.21686;
  }
  <D.19205>:
  block = block->next;
  <D.19208>:
  if (block != 0B) goto <D.19207>; else goto <D.19209>;
  <D.19209>:
  D.21686 = 0B;
  return D.21686;
}


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

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


major_is_valid_object (char * object)
{
  char * D.21692;
  char * D.21694;
  int object.142;
  char * D.21696;
  int D.21697;
  int D.21698;
  int D.21699;
  int D.21700;
  sizetype D.21701;
  sizetype D.21702;
  gboolean D.21705;
  int iftmp.143;
  void * D.21710;
  char * D.21712;
  struct MSBlockInfo * block;

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

    D.21692 = block->block;
    if (D.21692 > object) goto <D.21690>; else goto <D.21693>;
    <D.21693>:
    D.21692 = block->block;
    D.21694 = D.21692 + 16384;
    if (D.21694 <= object) goto <D.21690>; else goto <D.21691>;
    <D.21690>:
    // predicted unlikely by continue predictor.
    goto <D.19190>;
    <D.21691>:
    object.142 = (int) object;
    D.21692 = block->block;
    D.21696 = D.21692 + 16;
    D.21697 = (int) D.21696;
    D.21698 = object.142 - D.21697;
    D.21699 = block->obj_size;
    idx = D.21698 / D.21699;
    D.21692 = block->block;
    D.21699 = block->obj_size;
    D.21700 = D.21699 * idx;
    D.21701 = (sizetype) D.21700;
    D.21702 = D.21701 + 16;
    obj = D.21692 + D.21702;
    if (obj != object) goto <D.21703>; else goto <D.21704>;
    <D.21703>:
    D.21705 = 0;
    return D.21705;
    <D.21704>:
    D.21710 = MEM[(void * *)obj];
    if (D.21710 != 0B) goto <D.21711>; else goto <D.21707>;
    <D.21711>:
    D.21712 = MEM[(char * *)obj];
    D.21692 = block->block;
    if (D.21712 < D.21692) goto <D.21708>; else goto <D.21713>;
    <D.21713>:
    D.21712 = MEM[(char * *)obj];
    D.21692 = block->block;
    D.21694 = D.21692 + 16384;
    if (D.21712 >= D.21694) goto <D.21708>; else goto <D.21707>;
    <D.21708>:
    iftmp.143 = 1;
    goto <D.21709>;
    <D.21707>:
    iftmp.143 = 0;
    <D.21709>:
    D.21705 = iftmp.143;
    return D.21705;
  }
  <D.19190>:
  block = block->next;
  <D.19192>:
  if (block != 0B) goto <D.19191>; else goto <D.19193>;
  <D.19193>:
  D.21705 = 0;
  return D.21705;
}


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

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


major_print_gc_param_usage ()
{
  struct _IO_FILE * stderr.145;

  stderr.145 = stderr;
  fprintf (stderr.145, "  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.21717;
  char * D.21720;
  unsigned int percentage.146;
  struct _IO_FILE * stderr.147;
  float D.21725;
  float evacuation_threshold.148;
  gboolean D.21727;
  int D.19897;
  int iftmp.149;
  int D.19896;
  const char[11] * D.21731;
  unsigned char D.21732;
  int D.21733;
  unsigned char D.21734;
  int D.21735;
  _Bool D.21736;
  _Bool D.21737;
  _Bool D.21738;
  const unsigned char * D.21741;
  unsigned char D.21742;
  int D.21743;
  const unsigned char * D.21744;
  unsigned char D.21745;
  int D.21746;
  _Bool D.21747;
  _Bool D.21748;
  const unsigned char * D.21751;
  unsigned char D.21752;
  int D.21753;
  const unsigned char * D.21754;
  unsigned char D.21755;
  int D.21756;
  _Bool D.21757;
  _Bool D.21758;
  const unsigned char * D.21761;
  unsigned char D.21762;
  int D.21763;
  const unsigned char * D.21764;
  unsigned char D.21765;
  int D.21766;
  int D.19906;
  int iftmp.150;
  int D.19905;
  const char[14] * D.21773;
  unsigned char D.21774;
  int D.21775;
  unsigned char D.21776;
  int D.21777;
  _Bool D.21778;
  _Bool D.21779;
  _Bool D.21780;
  const unsigned char * D.21783;
  unsigned char D.21784;
  int D.21785;
  const unsigned char * D.21786;
  unsigned char D.21787;
  int D.21788;
  _Bool D.21789;
  _Bool D.21790;
  const unsigned char * D.21793;
  unsigned char D.21794;
  int D.21795;
  const unsigned char * D.21796;
  unsigned char D.21797;
  int D.21798;
  _Bool D.21799;
  _Bool D.21800;
  const unsigned char * D.21803;
  unsigned char D.21804;
  int D.21805;
  const unsigned char * D.21806;
  unsigned char D.21807;
  int D.21808;

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

    D.21720 = __builtin_strchr (opt, 61);
    arg = D.21720 + 1;
    percentage = atoi (arg);
    percentage.146 = (unsigned int) percentage;
    if (percentage.146 > 100) goto <D.21722>; else goto <D.21723>;
    <D.21722>:
    stderr.147 = stderr;
    fprintf (stderr.147, "evacuation-threshold must be an integer in the range 0-100.\n");
    exit (1);
    <D.21723>:
    D.21725 = (float) percentage;
    evacuation_threshold.148 = D.21725 / 1.0e+2;
    evacuation_threshold = evacuation_threshold.148;
    D.21727 = 1;
    return D.21727;
  }
  <D.21719>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = opt;
      D.21731 = "lazy-sweep";
      D.21732 = MEM[(const unsigned char *)D.21731];
      D.21733 = (int) D.21732;
      D.21734 = *__s2;
      D.21735 = (int) D.21734;
      __result = D.21733 - D.21735;
      {
        D.21736 = __s2_len != 0;
        D.21737 = __result == 0;
        D.21738 = D.21736 & D.21737;
        if (D.21738 != 0) goto <D.21739>; else goto <D.21740>;
        <D.21739>:
        D.21741 = &MEM[(void *)"lazy-sweep" + 1B];
        D.21742 = *D.21741;
        D.21743 = (int) D.21742;
        D.21744 = __s2 + 1;
        D.21745 = *D.21744;
        D.21746 = (int) D.21745;
        __result = D.21743 - D.21746;
        D.21747 = __s2_len > 1;
        D.21737 = __result == 0;
        D.21748 = D.21747 & D.21737;
        if (D.21748 != 0) goto <D.21749>; else goto <D.21750>;
        <D.21749>:
        D.21751 = &MEM[(void *)"lazy-sweep" + 2B];
        D.21752 = *D.21751;
        D.21753 = (int) D.21752;
        D.21754 = __s2 + 2;
        D.21755 = *D.21754;
        D.21756 = (int) D.21755;
        __result = D.21753 - D.21756;
        D.21757 = __s2_len > 2;
        D.21737 = __result == 0;
        D.21758 = D.21757 & D.21737;
        if (D.21758 != 0) goto <D.21759>; else goto <D.21760>;
        <D.21759>:
        D.21761 = &MEM[(void *)"lazy-sweep" + 3B];
        D.21762 = *D.21761;
        D.21763 = (int) D.21762;
        D.21764 = __s2 + 3;
        D.21765 = *D.21764;
        D.21766 = (int) D.21765;
        __result = D.21763 - D.21766;
        <D.21760>:
        <D.21750>:
        <D.21740>:
      }
      D.19896 = __result;
    }
    iftmp.149 = -D.19896;
    goto <D.21767>;
    <D.21730>:
    iftmp.149 = __builtin_strcmp (opt, "lazy-sweep");
    <D.21767>:
    D.19897 = iftmp.149;
  }
  if (D.19897 == 0) goto <D.21768>; else goto <D.21769>;
  <D.21768>:
  lazy_sweep = 1;
  D.21727 = 1;
  return D.21727;
  <D.21769>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = opt;
      D.21773 = "no-lazy-sweep";
      D.21774 = MEM[(const unsigned char *)D.21773];
      D.21775 = (int) D.21774;
      D.21776 = *__s2;
      D.21777 = (int) D.21776;
      __result = D.21775 - D.21777;
      {
        D.21778 = __s2_len != 0;
        D.21779 = __result == 0;
        D.21780 = D.21778 & D.21779;
        if (D.21780 != 0) goto <D.21781>; else goto <D.21782>;
        <D.21781>:
        D.21783 = &MEM[(void *)"no-lazy-sweep" + 1B];
        D.21784 = *D.21783;
        D.21785 = (int) D.21784;
        D.21786 = __s2 + 1;
        D.21787 = *D.21786;
        D.21788 = (int) D.21787;
        __result = D.21785 - D.21788;
        D.21789 = __s2_len > 1;
        D.21779 = __result == 0;
        D.21790 = D.21789 & D.21779;
        if (D.21790 != 0) goto <D.21791>; else goto <D.21792>;
        <D.21791>:
        D.21793 = &MEM[(void *)"no-lazy-sweep" + 2B];
        D.21794 = *D.21793;
        D.21795 = (int) D.21794;
        D.21796 = __s2 + 2;
        D.21797 = *D.21796;
        D.21798 = (int) D.21797;
        __result = D.21795 - D.21798;
        D.21799 = __s2_len > 2;
        D.21779 = __result == 0;
        D.21800 = D.21799 & D.21779;
        if (D.21800 != 0) goto <D.21801>; else goto <D.21802>;
        <D.21801>:
        D.21803 = &MEM[(void *)"no-lazy-sweep" + 3B];
        D.21804 = *D.21803;
        D.21805 = (int) D.21804;
        D.21806 = __s2 + 3;
        D.21807 = *D.21806;
        D.21808 = (int) D.21807;
        __result = D.21805 - D.21808;
        <D.21802>:
        <D.21792>:
        <D.21782>:
      }
      D.19905 = __result;
    }
    iftmp.150 = -D.19905;
    goto <D.21809>;
    <D.21772>:
    iftmp.150 = __builtin_strcmp (opt, "no-lazy-sweep");
    <D.21809>:
    D.19906 = iftmp.150;
  }
  if (D.19906 == 0) goto <D.21810>; else goto <D.21811>;
  <D.21810>:
  lazy_sweep = 0;
  D.21727 = 1;
  return D.21727;
  <D.21811>:
  D.21727 = 0;
  return D.21727;
}


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

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


get_num_major_sections ()
{
  int D.21815;

  D.21815 = num_major_sections;
  return D.21815;
}


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.21817;
  char * D.21820;
  gboolean D.21823;
  <unnamed-unsigned:1> D.21824;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.19086>;
  <D.19085>:
  D.21817 = block->block;
  if (D.21817 <= ptr) goto <D.21818>; else goto <D.21819>;
  <D.21818>:
  D.21817 = block->block;
  D.21820 = D.21817 + 16384;
  if (D.21820 >= ptr) goto <D.21821>; else goto <D.21822>;
  <D.21821>:
  D.21824 = block->pinned;
  D.21823 = (gboolean) D.21824;
  return D.21823;
  <D.21822>:
  <D.21819>:
  block = block->next;
  <D.19086>:
  if (block != 0B) goto <D.19085>; else goto <D.19087>;
  <D.19087>:
  D.21823 = 0;
  return D.21823;
}


major_ptr_is_in_non_pinned_space (char * ptr, char * * start)
{
  char * D.21826;
  char * D.21829;
  int D.21832;
  int D.21833;
  sizetype D.21834;
  sizetype D.21835;
  char * D.21836;
  int D.21839;
  int D.21840;
  sizetype D.21841;
  sizetype D.21842;
  char * D.21843;
  gboolean D.21846;
  unsigned char D.21847;
  unsigned char D.21848;
  _Bool D.21849;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.19165>;
  <D.19164>:
  D.21826 = block->block;
  if (D.21826 <= ptr) goto <D.21827>; else goto <D.21828>;
  <D.21827>:
  D.21826 = block->block;
  D.21829 = D.21826 + 16384;
  if (D.21829 >= ptr) goto <D.21830>; else goto <D.21831>;
  <D.21830>:
  {
    int count;
    int i;

    D.21832 = block->obj_size;
    count = 16368 / D.21832;
    *start = 0B;
    i = 0;
    goto <D.19163>;
    <D.19162>:
    D.21826 = block->block;
    D.21832 = block->obj_size;
    D.21833 = D.21832 * i;
    D.21834 = (sizetype) D.21833;
    D.21835 = D.21834 + 16;
    D.21836 = D.21826 + D.21835;
    if (D.21836 <= ptr) goto <D.21837>; else goto <D.21838>;
    <D.21837>:
    D.21826 = block->block;
    D.21832 = block->obj_size;
    D.21839 = i + 1;
    D.21840 = D.21832 * D.21839;
    D.21841 = (sizetype) D.21840;
    D.21842 = D.21841 + 16;
    D.21843 = D.21826 + D.21842;
    if (D.21843 > ptr) goto <D.21844>; else goto <D.21845>;
    <D.21844>:
    D.21826 = block->block;
    D.21832 = block->obj_size;
    D.21833 = D.21832 * i;
    D.21834 = (sizetype) D.21833;
    D.21835 = D.21834 + 16;
    D.21836 = D.21826 + D.21835;
    *start = D.21836;
    goto <D.19161>;
    <D.21845>:
    <D.21838>:
    i = i + 1;
    <D.19163>:
    if (i <= count) goto <D.19162>; else goto <D.19161>;
    <D.19161>:
    D.21847 = BIT_FIELD_REF <*block, 8, 96>;
    D.21848 = D.21847 & 1;
    D.21849 = D.21848 == 0;
    D.21846 = (gboolean) D.21849;
    return D.21846;
  }
  <D.21831>:
  <D.21828>:
  block = block->next;
  <D.19165>:
  if (block != 0B) goto <D.19164>; else goto <D.19166>;
  <D.19166>:
  D.21846 = 0;
  return D.21846;
}


major_have_computer_minor_collection_allowance ()
{
  unsigned int D.21851;
  unsigned int D.21852;
  int have_swept.151;
  _Bool D.21854;
  long int D.21855;
  long int D.21856;
  int num_empty_blocks.152;
  _Bool D.21862;
  long int D.21863;
  long int D.21864;
  unsigned int num_empty_blocks_orig.153;
  unsigned int D.21868;
  int i.154;
  unsigned int i.155;
  unsigned int D.21872;
  void * * D.21873;
  _Bool D.21874;
  long int D.21875;
  long int D.21876;
  unsigned int num_empty_blocks.156;
  unsigned int i.157;
  unsigned int D.21881;
  void * * D.21882;
  _Bool D.21883;
  long int D.21884;
  long int D.21885;
  unsigned int dest.158;
  unsigned int D.21891;
  void * * D.21892;
  _Bool D.21895;
  _Bool D.21896;
  _Bool D.21897;
  int D.21898;
  _Bool D.21899;
  long int D.21900;
  long int D.21901;
  sizetype d.159;
  sizetype D.21905;
  sizetype D.21906;
  void * * D.21907;
  void * D.21908;
  char * D.21909;
  int D.21912;
  int D.21913;
  int D.21916;
  unsigned int D.21917;
  unsigned int first.160;
  unsigned int D.21919;
  void * * D.21920;
  void * D.21921;
  unsigned int j.161;
  unsigned int D.21923;
  void * * D.21924;
  int num_empty_blocks.162;
  long long int D.21926;
  long long int stat_major_blocks_freed.163;
  long long int stat_major_blocks_freed.164;
  long long int stat_major_blocks_freed_ideal.165;
  long long int stat_major_blocks_freed_ideal.166;
  long long int stat_major_blocks_freed_less_ideal.167;
  long long int stat_major_blocks_freed_less_ideal.168;
  _Bool D.21936;
  _Bool D.21937;
  _Bool D.21938;
  int D.21939;
  _Bool D.21940;
  long int D.21941;
  long int D.21942;
  _Bool D.21945;
  long int D.21946;
  long int D.21947;
  _Bool D.21951;
  long int D.21952;
  long int D.21953;
  _Bool D.21956;
  long int D.21957;
  long int D.21958;
  int num_major_sections.169;
  void * empty_blocks.170;
  int num_empty_blocks.171;
  long long int stat_major_blocks_freed.172;
  long long int stat_major_blocks_freed_individual.173;
  long long int stat_major_blocks_freed_individual.174;
  int section_reserve;
  void fallback = <<< error >>>;

  D.21851 = sgen_get_minor_collection_allowance ();
  D.21852 = D.21851 / 16384;
  section_reserve = (int) D.21852;
  have_swept.151 = have_swept;
  D.21854 = have_swept.151 == 0;
  D.21855 = (long int) D.21854;
  D.21856 = __builtin_expect (D.21855, 0);
  if (D.21856 != 0) goto <D.21857>; else goto <D.21858>;
  <D.21857>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 1898, "have_swept");
  <D.21858>:
  {
    int i;
    int num_empty_blocks_orig;
    int num_blocks;
    int arr_length;
    void * block;
    void * * empty_block_arr;
    void * * rebuild_next;

    num_empty_blocks.152 = num_empty_blocks;
    if (num_empty_blocks.152 <= section_reserve) goto <D.21860>; else goto <D.21861>;
    <D.21860>:
    return;
    <D.21861>:
    num_empty_blocks.152 = num_empty_blocks;
    D.21862 = num_empty_blocks.152 <= 0;
    D.21863 = (long int) D.21862;
    D.21864 = __builtin_expect (D.21863, 0);
    if (D.21864 != 0) goto <D.21865>; else goto <D.21866>;
    <D.21865>:
    monoeg_g_log (0B, 4, "section reserve can\'t be negative");
    <D.19813>:
    goto <D.19813>;
    <D.21866>:
    num_empty_blocks_orig = num_empty_blocks;
    num_empty_blocks_orig.153 = (unsigned int) num_empty_blocks_orig;
    D.21868 = num_empty_blocks_orig.153 * 4;
    empty_block_arr = sgen_alloc_internal_dynamic (D.21868, 17, 0);
    if (empty_block_arr == 0B) goto fallback; else goto <D.21869>;
    <D.21869>:
    i = 0;
    block = empty_blocks;
    goto <D.19816>;
    <D.19815>:
    i.154 = i;
    i = i.154 + 1;
    i.155 = (unsigned int) i.154;
    D.21872 = i.155 * 4;
    D.21873 = empty_block_arr + D.21872;
    *D.21873 = block;
    block = MEM[(void * *)block];
    <D.19816>:
    if (block != 0B) goto <D.19815>; else goto <D.19817>;
    <D.19817>:
    num_empty_blocks.152 = num_empty_blocks;
    D.21874 = i != num_empty_blocks.152;
    D.21875 = (long int) D.21874;
    D.21876 = __builtin_expect (D.21875, 0);
    if (D.21876 != 0) goto <D.21877>; else goto <D.21878>;
    <D.21877>:
    monoeg_g_log (0B, 4, "empty block count wrong");
    <D.19818>:
    goto <D.19818>;
    <D.21878>:
    num_empty_blocks.152 = num_empty_blocks;
    num_empty_blocks.156 = (unsigned int) num_empty_blocks.152;
    sgen_qsort (empty_block_arr, num_empty_blocks.156, 4, compare_pointers);
    arr_length = num_empty_blocks_orig;
    num_blocks = 32;
    goto <D.19836>;
    <D.19835>:
    {
      int first;
      int dest;

      first = -1;
      dest = 0;
      dest = 0;
      i = 0;
      goto <D.19831>;
      <D.19830>:
      {
        int d;
        void * block;

        d = dest;
        i.157 = (unsigned int) i;
        D.21881 = i.157 * 4;
        D.21882 = empty_block_arr + D.21881;
        block = *D.21882;
        D.21883 = block == 0B;
        D.21884 = (long int) D.21883;
        D.21885 = __builtin_expect (D.21884, 0);
        if (D.21885 != 0) goto <D.21886>; else goto <D.21887>;
        <D.21886>:
        monoeg_g_log (0B, 4, "we\'re not shifting correctly");
        <D.19823>:
        goto <D.19823>;
        <D.21887>:
        if (i != dest) goto <D.21888>; else goto <D.21889>;
        <D.21888>:
        dest.158 = (unsigned int) dest;
        D.21891 = dest.158 * 4;
        D.21892 = empty_block_arr + D.21891;
        *D.21892 = block;
        i.157 = (unsigned int) i;
        D.21881 = i.157 * 4;
        D.21882 = empty_block_arr + D.21881;
        *D.21882 = 0B;
        <D.21889>:
        dest = dest + 1;
        if (first < 0) goto <D.21893>; else goto <D.21894>;
        <D.21893>:
        first = d;
        // predicted unlikely by continue predictor.
        goto <D.19824>;
        <D.21894>:
        D.21895 = first < 0;
        D.21896 = d <= first;
        D.21897 = D.21895 | D.21896;
        D.21898 = (int) D.21897;
        D.21899 = D.21898 != 0;
        D.21900 = (long int) D.21899;
        D.21901 = __builtin_expect (D.21900, 0);
        if (D.21901 != 0) goto <D.21902>; else goto <D.21903>;
        <D.21902>:
        monoeg_g_log (0B, 4, "algorithm is wrong");
        <D.19825>:
        goto <D.19825>;
        <D.21903>:
        d.159 = (sizetype) d;
        D.21905 = d.159 + 1073741823;
        D.21906 = D.21905 * 4;
        D.21907 = empty_block_arr + D.21906;
        D.21908 = *D.21907;
        D.21909 = D.21908 + 16384;
        if (D.21909 != block) goto <D.21910>; else goto <D.21911>;
        <D.21910>:
        first = d;
        // predicted unlikely by continue predictor.
        goto <D.19824>;
        <D.21911>:
        D.21912 = d + 1;
        D.21913 = D.21912 - first;
        if (D.21913 == num_blocks) goto <D.21914>; else goto <D.21915>;
        <D.21914>:
        {
          int j;

          D.21916 = num_blocks * 16384;
          D.21917 = (unsigned int) D.21916;
          first.160 = (unsigned int) first;
          D.21919 = first.160 * 4;
          D.21920 = empty_block_arr + D.21919;
          D.21921 = *D.21920;
          sgen_free_os_memory (D.21921, D.21917, 1);
          j = first;
          goto <D.19828>;
          <D.19827>:
          j.161 = (unsigned int) j;
          D.21923 = j.161 * 4;
          D.21924 = empty_block_arr + D.21923;
          *D.21924 = 0B;
          j = j + 1;
          <D.19828>:
          if (j <= d) goto <D.19827>; else goto <D.19829>;
          <D.19829>:
          dest = first;
          first = -1;
          num_empty_blocks.152 = num_empty_blocks;
          num_empty_blocks.162 = num_empty_blocks.152 - num_blocks;
          num_empty_blocks = num_empty_blocks.162;
          D.21926 = (long long int) num_blocks;
          stat_major_blocks_freed.163 = stat_major_blocks_freed;
          stat_major_blocks_freed.164 = D.21926 + stat_major_blocks_freed.163;
          stat_major_blocks_freed = stat_major_blocks_freed.164;
          if (num_blocks == 32) goto <D.21929>; else goto <D.21930>;
          <D.21929>:
          D.21926 = (long long int) num_blocks;
          stat_major_blocks_freed_ideal.165 = stat_major_blocks_freed_ideal;
          stat_major_blocks_freed_ideal.166 = D.21926 + stat_major_blocks_freed_ideal.165;
          stat_major_blocks_freed_ideal = stat_major_blocks_freed_ideal.166;
          goto <D.21933>;
          <D.21930>:
          D.21926 = (long long int) num_blocks;
          stat_major_blocks_freed_less_ideal.167 = stat_major_blocks_freed_less_ideal;
          stat_major_blocks_freed_less_ideal.168 = D.21926 + stat_major_blocks_freed_less_ideal.167;
          stat_major_blocks_freed_less_ideal = stat_major_blocks_freed_less_ideal.168;
          <D.21933>:
        }
        <D.21915>:
      }
      <D.19824>:
      i = i + 1;
      <D.19831>:
      if (i < arr_length) goto <D.19830>; else goto <D.19832>;
      <D.19832>:
      D.21936 = dest > i;
      D.21937 = dest > arr_length;
      D.21938 = D.21936 | D.21937;
      D.21939 = (int) D.21938;
      D.21940 = D.21939 != 0;
      D.21941 = (long int) D.21940;
      D.21942 = __builtin_expect (D.21941, 0);
      if (D.21942 != 0) goto <D.21943>; else goto <D.21944>;
      <D.21943>:
      monoeg_g_log (0B, 4, "array length is off");
      <D.19833>:
      goto <D.19833>;
      <D.21944>:
      arr_length = dest;
      num_empty_blocks.152 = num_empty_blocks;
      D.21945 = arr_length != num_empty_blocks.152;
      D.21946 = (long int) D.21945;
      D.21947 = __builtin_expect (D.21946, 0);
      if (D.21947 != 0) goto <D.21948>; else goto <D.21949>;
      <D.21948>:
      monoeg_g_log (0B, 4, "array length is off");
      <D.19834>:
      goto <D.19834>;
      <D.21949>:
      num_blocks = num_blocks >> 1;
    }
    <D.19836>:
    num_empty_blocks.152 = num_empty_blocks;
    if (num_empty_blocks.152 > section_reserve) goto <D.21950>; else goto <D.19837>;
    <D.21950>:
    if (num_blocks > 1) goto <D.19835>; else goto <D.19837>;
    <D.19837>:
    rebuild_next = &empty_blocks;
    i = 0;
    goto <D.19841>;
    <D.19840>:
    {
      void * block;

      i.157 = (unsigned int) i;
      D.21881 = i.157 * 4;
      D.21882 = empty_block_arr + D.21881;
      block = *D.21882;
      D.21951 = block == 0B;
      D.21952 = (long int) D.21951;
      D.21953 = __builtin_expect (D.21952, 0);
      if (D.21953 != 0) goto <D.21954>; else goto <D.21955>;
      <D.21954>:
      monoeg_g_log (0B, 4, "we\'re missing blocks");
      <D.19839>:
      goto <D.19839>;
      <D.21955>:
      *rebuild_next = block;
      rebuild_next = block;
    }
    i = i + 1;
    <D.19841>:
    if (i < arr_length) goto <D.19840>; else goto <D.19842>;
    <D.19842>:
    *rebuild_next = 0B;
    num_empty_blocks_orig.153 = (unsigned int) num_empty_blocks_orig;
    D.21868 = num_empty_blocks_orig.153 * 4;
    sgen_free_internal_dynamic (empty_block_arr, D.21868, 17);
  }
  num_empty_blocks.152 = num_empty_blocks;
  D.21956 = num_empty_blocks.152 < 0;
  D.21957 = (long int) D.21956;
  D.21958 = __builtin_expect (D.21957, 0);
  if (D.21958 != 0) goto <D.21959>; else goto <D.21960>;
  <D.21959>:
  monoeg_g_log (0B, 4, "we freed more blocks than we had in the first place?");
  <D.19843>:
  goto <D.19843>;
  <D.21960>:
  fallback:
  num_empty_blocks.152 = num_empty_blocks;
  num_major_sections.169 = num_major_sections;
  if (num_empty_blocks.152 <= num_major_sections.169) goto <D.21962>; else goto <D.21963>;
  <D.21962>:
  return;
  <D.21963>:
  goto <D.19846>;
  <D.19845>:
  {
    void * next;

    empty_blocks.170 = empty_blocks;
    next = MEM[(void * *)empty_blocks.170];
    empty_blocks.170 = empty_blocks;
    sgen_free_os_memory (empty_blocks.170, 16384, 1);
    empty_blocks = next;
    num_empty_blocks.152 = num_empty_blocks;
    num_empty_blocks.171 = num_empty_blocks.152 + -1;
    num_empty_blocks = num_empty_blocks.171;
    stat_major_blocks_freed.163 = stat_major_blocks_freed;
    stat_major_blocks_freed.172 = stat_major_blocks_freed.163 + 1;
    stat_major_blocks_freed = stat_major_blocks_freed.172;
    stat_major_blocks_freed_individual.173 = stat_major_blocks_freed_individual;
    stat_major_blocks_freed_individual.174 = stat_major_blocks_freed_individual.173 + 1;
    stat_major_blocks_freed_individual = stat_major_blocks_freed_individual.174;
  }
  <D.19846>:
  num_empty_blocks.152 = num_empty_blocks;
  if (num_empty_blocks.152 > section_reserve) goto <D.19845>; else goto <D.19847>;
  <D.19847>:
}


compare_pointers (const void * va, const void * vb)
{
  int D.21972;
  char * a;
  char * b;

  a = MEM[(char * *)va];
  b = MEM[(char * *)vb];
  if (a < b) goto <D.21970>; else goto <D.21971>;
  <D.21970>:
  D.21972 = -1;
  return D.21972;
  <D.21971>:
  if (a > b) goto <D.21973>; else goto <D.21974>;
  <D.21973>:
  D.21972 = 1;
  return D.21972;
  <D.21974>:
  D.21972 = 0;
  return D.21972;
}


major_finish_major_collection ()
{

}


major_start_major_collection ()
{
  gboolean * evacuate_block_obj_sizes.175;
  unsigned int i.176;
  unsigned int D.21978;
  gboolean * D.21979;
  int D.21980;
  struct MSBlockInfo * * D.21983;
  struct MSBlockInfo * * D.21984;
  struct MSBlockInfo * * D.21985;
  struct MSBlockInfo * * D.21986;
  int num_block_obj_sizes.177;
  int lazy_sweep.178;
  struct MSBlockInfo * D.21991;
  int i;

  i = 0;
  goto <D.19786>;
  <D.19785>:
  evacuate_block_obj_sizes.175 = evacuate_block_obj_sizes;
  i.176 = (unsigned int) i;
  D.21978 = i.176 * 4;
  D.21979 = evacuate_block_obj_sizes.175 + D.21978;
  D.21980 = *D.21979;
  if (D.21980 == 0) goto <D.21981>; else goto <D.21982>;
  <D.21981>:
  // predicted unlikely by continue predictor.
  goto <D.19784>;
  <D.21982>:
  D.21983 = free_block_lists[0];
  i.176 = (unsigned int) i;
  D.21978 = i.176 * 4;
  D.21984 = D.21983 + D.21978;
  *D.21984 = 0B;
  D.21985 = free_block_lists[2];
  i.176 = (unsigned int) i;
  D.21978 = i.176 * 4;
  D.21986 = D.21985 + D.21978;
  *D.21986 = 0B;
  <D.19784>:
  i = i + 1;
  <D.19786>:
  num_block_obj_sizes.177 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.177) goto <D.19785>; else goto <D.19787>;
  <D.19787>:
  lazy_sweep.178 = lazy_sweep;
  if (lazy_sweep.178 != 0) goto <D.21989>; else goto <D.21990>;
  <D.21989>:
  {
    struct MSBlockInfo * * iter;

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

      block = *iter;
      sweep_block (block, 1);
      iter = &block->next;
    }
    <D.19791>:
    D.21991 = *iter;
    if (D.21991 != 0B) goto <D.19790>; else goto <D.19792>;
    <D.19792>:
  }
  <D.21990>:
}


sweep_block (struct MSBlockInfo * block, gboolean during_major_collection)
{
  int D.21994;
  _Bool D.21995;
  long int D.21996;
  long int D.21997;
  unsigned char D.22000;
  unsigned char D.22001;
  int D.22004;
  mword[64] * D.22005;
  void * * D.22006;
  int count;
  void * reversed;

  reversed = 0B;
  if (during_major_collection == 0) goto <D.21992>; else goto <D.21993>;
  <D.21992>:
  D.21994 = sgen_concurrent_collection_in_progress ();
  D.21995 = D.21994 != 0;
  D.21996 = (long int) D.21995;
  D.21997 = __builtin_expect (D.21996, 0);
  if (D.21997 != 0) goto <D.21998>; else goto <D.21999>;
  <D.21998>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 1551, "!sgen_concurrent_collection_in_progress ()");
  <D.21999>:
  <D.21993>:
  D.22000 = BIT_FIELD_REF <*block, 8, 96>;
  D.22001 = D.22000 & 16;
  if (D.22001 != 0) goto <D.22002>; else goto <D.22003>;
  <D.22002>:
  return;
  <D.22003>:
  D.22004 = block->obj_size;
  count = 16368 / D.22004;
  block->free_list = 0B;
  D.22004 = block->obj_size;
  switch (D.22004) <default: <D.19689>, case 16: <D.19687>>
  <D.19687>:
  sweep_block_for_size (block, count, 16);
  goto <D.19688>;
  <D.19689>:
  D.22004 = block->obj_size;
  sweep_block_for_size (block, count, D.22004);
  goto <D.19688>;
  <D.19688>:
  D.22005 = &block->mark_words;
  memset (D.22005, 0, 256);
  reversed = 0B;
  goto <D.19692>;
  <D.19691>:
  {
    void * next;

    D.22006 = block->free_list;
    next = *D.22006;
    D.22006 = block->free_list;
    *D.22006 = reversed;
    reversed = block->free_list;
    block->free_list = next;
  }
  <D.19692>:
  D.22006 = block->free_list;
  if (D.22006 != 0B) goto <D.19691>; else goto <D.19693>;
  <D.19693>:
  block->free_list = reversed;
  block->swept = 1;
}


sweep_block_for_size (struct MSBlockInfo * block, int count, int obj_size)
{
  char * D.22008;
  int D.22009;
  sizetype D.22010;
  sizetype D.22011;
  int obj.179;
  int obj.180;
  int D.22014;
  int D.22015;
  unsigned int D.22019;
  long int D.22020;
  long unsigned int D.22021;
  long unsigned int D.22022;
  void * D.22030;
  char * D.22033;
  char * D.22035;
  unsigned int obj_size.181;
  void * * D.22037;
  int obj_index;

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

    D.22008 = block->block;
    D.22009 = obj_size * obj_index;
    D.22010 = (sizetype) D.22009;
    D.22011 = D.22010 + 16;
    obj = D.22008 + D.22011;
    {
      int i;

      obj.179 = (int) obj;
      obj.180 = (int) obj;
      D.22014 = obj.180 & -16384;
      D.22015 = obj.179 - D.22014;
      i = D.22015 >> 3;
      if (1 != 0) goto <D.22016>; else goto <D.22017>;
      <D.22016>:
      word = i >> 5;
      bit = i & 31;
      goto <D.22018>;
      <D.22017>:
      word = i >> 6;
      bit = i & 63;
      <D.22018>:
    }
    D.22019 = block->mark_words[word];
    D.22020 = 1 << bit;
    D.22021 = (long unsigned int) D.22020;
    D.22022 = D.22019 & D.22021;
    if (D.22022 != 0) goto <D.22023>; else goto <D.22024>;
    <D.22023>:
    if (0 != 0) goto <D.22025>; else goto <D.22026>;
    <D.22025>:
    monoeg_g_log (0B, 4, "object %p not allocated", obj);
    <D.19677>:
    goto <D.19677>;
    <D.22026>:
    goto <D.22027>;
    <D.22024>:
    D.22030 = MEM[(void * *)obj];
    if (D.22030 != 0B) goto <D.22031>; else goto <D.22032>;
    <D.22031>:
    D.22033 = MEM[(char * *)obj];
    D.22008 = block->block;
    if (D.22033 < D.22008) goto <D.22028>; else goto <D.22034>;
    <D.22034>:
    D.22033 = MEM[(char * *)obj];
    D.22008 = block->block;
    D.22035 = D.22008 + 16384;
    if (D.22033 >= D.22035) goto <D.22028>; else goto <D.22029>;
    <D.22028>:
    obj_size.181 = (unsigned int) obj_size;
    memset (obj, 0, obj_size.181);
    <D.22029>:
    <D.22032>:
    D.22037 = block->free_list;
    MEM[(void * *)obj] = D.22037;
    block->free_list = obj;
    <D.22027>:
  }
  obj_index = obj_index + 1;
  <D.19679>:
  if (obj_index < count) goto <D.19678>; else goto <D.19680>;
  <D.19680>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.22040;
  int D.22045;
  void * D.22047;
  unsigned int D.22048;

  D.22040 = __builtin_constant_p (__len);
  if (D.22040 != 0) goto <D.22041>; else goto <D.22042>;
  <D.22041>:
  if (__len == 0) goto <D.22043>; else goto <D.22044>;
  <D.22043>:
  D.22045 = __builtin_constant_p (__ch);
  if (D.22045 == 0) goto <D.22038>; else goto <D.22046>;
  <D.22046>:
  if (__ch != 0) goto <D.22038>; else goto <D.22039>;
  <D.22038>:
  __warn_memset_zero_len ();
  D.22047 = __dest;
  return D.22047;
  <D.22039>:
  <D.22044>:
  <D.22042>:
  D.22048 = __builtin_object_size (__dest, 0);
  D.22047 = __builtin___memset_chk (__dest, __ch, __len, D.22048);
  return D.22047;
}


major_finish_nursery_collection ()
{
  int num_major_sections.182;
  int old_num_major_sections.183;
  int D.22052;

  num_major_sections.182 = num_major_sections;
  old_num_major_sections.183 = old_num_major_sections;
  D.22052 = num_major_sections.182 - old_num_major_sections.183;
  sgen_register_major_sections_alloced (D.22052);
}


major_start_nursery_collection ()
{
  int num_major_sections.184;

  num_major_sections.184 = num_major_sections;
  old_num_major_sections = num_major_sections.184;
}


major_get_used_size ()
{
  int D.22054;
  int D.22055;
  long long int D.22056;
  long long int D.22057;
  gint64 D.22058;
  gint64 size;
  struct MSBlockInfo * block;

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

    D.22054 = block->obj_size;
    count = 16368 / D.22054;
    D.22054 = block->obj_size;
    D.22055 = D.22054 * count;
    D.22056 = (long long int) D.22055;
    size = D.22056 + size;
    iter = block->free_list;
    goto <D.19876>;
    <D.19875>:
    D.22054 = block->obj_size;
    D.22057 = (long long int) D.22054;
    size = size - D.22057;
    iter = *iter;
    <D.19876>:
    if (iter != 0B) goto <D.19875>; else goto <D.19877>;
    <D.19877>:
  }
  block = block->next;
  <D.19879>:
  if (block != 0B) goto <D.19878>; else goto <D.19880>;
  <D.19880>:
  D.22058 = size;
  return D.22058;
}


major_dump_heap (struct FILE * heap_dump_file)
{
  int num_block_obj_sizes.185;
  unsigned int num_block_obj_sizes.186;
  unsigned int D.22062;
  unsigned int i.187;
  unsigned int D.22064;
  int * D.22065;
  int * D.22066;
  int D.22067;
  int D.22068;
  unsigned int index.188;
  unsigned int D.22070;
  int * D.22071;
  int D.22072;
  int D.22073;
  char * D.22076;
  int D.22077;
  sizetype D.22078;
  sizetype D.22079;
  char * D.22080;
  void * D.22081;
  char * D.22084;
  char * D.22086;
  int * D.22087;
  int D.22088;
  int D.22089;
  int D.22090;
  int * block_obj_sizes.189;
  int * D.22092;
  int D.22093;
  int D.22098;
  sizetype D.22099;
  sizetype D.22100;
  char * D.22101;
  void * D.22102;
  char * D.22104;
  int D.22110;
  sizetype D.22111;
  sizetype D.22112;
  char * D.22113;
  struct MSBlockInfo * block;
  int * slots_available;
  int * slots_used;
  int i;

  num_block_obj_sizes.185 = num_block_obj_sizes;
  num_block_obj_sizes.186 = (unsigned int) num_block_obj_sizes.185;
  D.22062 = num_block_obj_sizes.186 * 4;
  slots_available = __builtin_alloca (D.22062);
  num_block_obj_sizes.185 = num_block_obj_sizes;
  num_block_obj_sizes.186 = (unsigned int) num_block_obj_sizes.185;
  D.22062 = num_block_obj_sizes.186 * 4;
  slots_used = __builtin_alloca (D.22062);
  i = 0;
  goto <D.19221>;
  <D.19220>:
  i.187 = (unsigned int) i;
  D.22064 = i.187 * 4;
  D.22065 = slots_available + D.22064;
  i.187 = (unsigned int) i;
  D.22064 = i.187 * 4;
  D.22066 = slots_used + D.22064;
  *D.22066 = 0;
  D.22067 = *D.22066;
  *D.22065 = D.22067;
  i = i + 1;
  <D.19221>:
  num_block_obj_sizes.185 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.185) goto <D.19220>; else goto <D.19222>;
  <D.19222>:
  block = all_blocks;
  goto <D.19229>;
  <D.19228>:
  {
    int index;
    int count;

    D.22068 = block->obj_size;
    index = ms_find_block_obj_size_index (D.22068);
    D.22068 = block->obj_size;
    count = 16368 / D.22068;
    index.188 = (unsigned int) index;
    D.22070 = index.188 * 4;
    D.22071 = slots_available + D.22070;
    index.188 = (unsigned int) index;
    D.22070 = index.188 * 4;
    D.22071 = slots_available + D.22070;
    D.22072 = *D.22071;
    D.22073 = D.22072 + count;
    *D.22071 = D.22073;
    i = 0;
    goto <D.19226>;
    <D.19225>:
    D.22076 = block->block;
    D.22068 = block->obj_size;
    D.22077 = D.22068 * i;
    D.22078 = (sizetype) D.22077;
    D.22079 = D.22078 + 16;
    D.22080 = D.22076 + D.22079;
    D.22081 = MEM[(void * *)D.22080];
    if (D.22081 != 0B) goto <D.22082>; else goto <D.22083>;
    <D.22082>:
    D.22076 = block->block;
    D.22068 = block->obj_size;
    D.22077 = D.22068 * i;
    D.22078 = (sizetype) D.22077;
    D.22079 = D.22078 + 16;
    D.22080 = D.22076 + D.22079;
    D.22084 = MEM[(char * *)D.22080];
    D.22076 = block->block;
    if (D.22084 < D.22076) goto <D.22074>; else goto <D.22085>;
    <D.22085>:
    D.22076 = block->block;
    D.22068 = block->obj_size;
    D.22077 = D.22068 * i;
    D.22078 = (sizetype) D.22077;
    D.22079 = D.22078 + 16;
    D.22080 = D.22076 + D.22079;
    D.22084 = MEM[(char * *)D.22080];
    D.22076 = block->block;
    D.22086 = D.22076 + 16384;
    if (D.22084 >= D.22086) goto <D.22074>; else goto <D.22075>;
    <D.22074>:
    index.188 = (unsigned int) index;
    D.22070 = index.188 * 4;
    D.22087 = slots_used + D.22070;
    D.22088 = *D.22087;
    D.22089 = D.22088 + 1;
    *D.22087 = D.22089;
    <D.22075>:
    <D.22083>:
    i = i + 1;
    <D.19226>:
    if (i < count) goto <D.19225>; else goto <D.19227>;
    <D.19227>:
  }
  block = block->next;
  <D.19229>:
  if (block != 0B) goto <D.19228>; else goto <D.19230>;
  <D.19230>:
  fprintf (heap_dump_file, "<occupancies>\n");
  i = 0;
  goto <D.19232>;
  <D.19231>:
  i.187 = (unsigned int) i;
  D.22064 = i.187 * 4;
  D.22066 = slots_used + D.22064;
  D.22067 = *D.22066;
  i.187 = (unsigned int) i;
  D.22064 = i.187 * 4;
  D.22065 = slots_available + D.22064;
  D.22090 = *D.22065;
  block_obj_sizes.189 = block_obj_sizes;
  i.187 = (unsigned int) i;
  D.22064 = i.187 * 4;
  D.22092 = block_obj_sizes.189 + D.22064;
  D.22093 = *D.22092;
  fprintf (heap_dump_file, "<occupancy size=\"%d\" available=\"%d\" used=\"%d\" />\n", D.22093, D.22090, D.22067);
  i = i + 1;
  <D.19232>:
  num_block_obj_sizes.185 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.185) goto <D.19231>; else goto <D.19233>;
  <D.19233>:
  fprintf (heap_dump_file, "</occupancies>\n");
  block = all_blocks;
  goto <D.19241>;
  <D.19240>:
  {
    int count;
    int i;
    int start;

    D.22068 = block->obj_size;
    count = 16368 / D.22068;
    start = -1;
    fprintf (heap_dump_file, "<section type=\"%s\" size=\"%zu\">\n", "old", 16368);
    i = 0;
    goto <D.19238>;
    <D.19237>:
    if (i < count) goto <D.22097>; else goto <D.22094>;
    <D.22097>:
    D.22076 = block->block;
    D.22068 = block->obj_size;
    D.22098 = D.22068 * i;
    D.22099 = (sizetype) D.22098;
    D.22100 = D.22099 + 16;
    D.22101 = D.22076 + D.22100;
    D.22102 = MEM[(void * *)D.22101];
    if (D.22102 != 0B) goto <D.22103>; else goto <D.22094>;
    <D.22103>:
    D.22076 = block->block;
    D.22068 = block->obj_size;
    D.22098 = D.22068 * i;
    D.22099 = (sizetype) D.22098;
    D.22100 = D.22099 + 16;
    D.22101 = D.22076 + D.22100;
    D.22104 = MEM[(char * *)D.22101];
    D.22076 = block->block;
    if (D.22104 < D.22076) goto <D.22095>; else goto <D.22105>;
    <D.22105>:
    D.22076 = block->block;
    D.22068 = block->obj_size;
    D.22098 = D.22068 * i;
    D.22099 = (sizetype) D.22098;
    D.22100 = D.22099 + 16;
    D.22101 = D.22076 + D.22100;
    D.22104 = MEM[(char * *)D.22101];
    D.22076 = block->block;
    D.22086 = D.22076 + 16384;
    if (D.22104 >= D.22086) goto <D.22095>; else goto <D.22094>;
    <D.22095>:
    if (start < 0) goto <D.22106>; else goto <D.22107>;
    <D.22106>:
    start = i;
    <D.22107>:
    goto <D.22096>;
    <D.22094>:
    if (start >= 0) goto <D.22108>; else goto <D.22109>;
    <D.22108>:
    D.22076 = block->block;
    D.22076 = block->block;
    D.22068 = block->obj_size;
    D.22098 = D.22068 * i;
    D.22099 = (sizetype) D.22098;
    D.22100 = D.22099 + 16;
    D.22101 = D.22076 + D.22100;
    D.22076 = block->block;
    D.22068 = block->obj_size;
    D.22110 = D.22068 * start;
    D.22111 = (sizetype) D.22110;
    D.22112 = D.22111 + 16;
    D.22113 = D.22076 + D.22112;
    sgen_dump_occupied (D.22113, D.22101, D.22076);
    start = -1;
    <D.22109>:
    <D.22096>:
    i = i + 1;
    <D.19238>:
    if (i <= count) goto <D.19237>; else goto <D.19239>;
    <D.19239>:
    fprintf (heap_dump_file, "</section>\n");
  }
  block = block->next;
  <D.19241>:
  if (block != 0B) goto <D.19240>; else goto <D.19242>;
  <D.19242>:
}


major_check_scan_starts ()
{

}


major_sweep ()
{
  ms_sweep ();
}


ms_sweep ()
{
  int num_block_obj_sizes.190;
  unsigned int num_block_obj_sizes.191;
  unsigned int D.22116;
  unsigned int i.192;
  unsigned int D.22118;
  int * D.22119;
  int * D.22120;
  int * D.22121;
  int D.22122;
  int D.22123;
  unsigned int j.193;
  unsigned int D.22125;
  struct MSBlockInfo * * D.22126;
  <unnamed-unsigned:1> D.22127;
  <unnamed-unsigned:1> D.22128;
  int D.22129;
  guint8 * D.22130;
  unsigned int D.22133;
  int D.22134;
  int lazy_sweep.194;
  unsigned int obj_size_index.195;
  unsigned int D.22147;
  int * D.22148;
  int D.22149;
  int D.22150;
  int * D.22151;
  int D.22152;
  int D.22153;
  int * D.22154;
  int D.22155;
  int D.22156;
  unsigned char D.22159;
  unsigned char D.22160;
  _Bool D.22161;
  int D.22162;
  int D.22163;
  int D.22164;
  int D.22165;
  int iftmp.196;
  int D.22167;
  int D.22168;
  unsigned int index.197;
  unsigned int D.22173;
  struct MSBlockInfo * * D.22174;
  struct MSBlockInfo * D.22175;
  struct MSBlockInfo * D.22177;
  char * D.22178;
  int num_major_sections.198;
  int num_major_sections.199;
  struct MSBlockInfo * D.22181;
  float D.22182;
  int D.22183;
  float D.22184;
  float evacuation_threshold.200;
  gboolean * evacuate_block_obj_sizes.201;
  gboolean * D.22191;
  int * block_obj_sizes.202;
  int * D.22193;
  int D.22194;
  int D.22195;
  int D.22196;
  int D.22199;
  unsigned int D.22200;
  unsigned int D.22201;
  float D.22202;
  float D.22203;
  float D.22204;
  float concurrent_evacuation_threshold.203;
  float D.22206;
  _Bool D.22207;
  int want_evacuation.204;
  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.190 = num_block_obj_sizes;
  num_block_obj_sizes.191 = (unsigned int) num_block_obj_sizes.190;
  D.22116 = num_block_obj_sizes.191 * 4;
  slots_available = __builtin_alloca (D.22116);
  num_block_obj_sizes.190 = num_block_obj_sizes;
  num_block_obj_sizes.191 = (unsigned int) num_block_obj_sizes.190;
  D.22116 = num_block_obj_sizes.191 * 4;
  slots_used = __builtin_alloca (D.22116);
  num_block_obj_sizes.190 = num_block_obj_sizes;
  num_block_obj_sizes.191 = (unsigned int) num_block_obj_sizes.190;
  D.22116 = num_block_obj_sizes.191 * 4;
  num_blocks = __builtin_alloca (D.22116);
  total_evacuate_heap = 0;
  total_evacuate_saved = 0;
  i = 0;
  goto <D.19709>;
  <D.19708>:
  i.192 = (unsigned int) i;
  D.22118 = i.192 * 4;
  D.22119 = slots_available + D.22118;
  i.192 = (unsigned int) i;
  D.22118 = i.192 * 4;
  D.22120 = slots_used + D.22118;
  i.192 = (unsigned int) i;
  D.22118 = i.192 * 4;
  D.22121 = num_blocks + D.22118;
  *D.22121 = 0;
  D.22122 = *D.22121;
  *D.22120 = D.22122;
  D.22123 = *D.22120;
  *D.22119 = D.22123;
  i = i + 1;
  <D.19709>:
  num_block_obj_sizes.190 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.190) goto <D.19708>; else goto <D.19710>;
  <D.19710>:
  i = 0;
  goto <D.19717>;
  <D.19716>:
  {
    struct MSBlockInfo * * free_blocks;
    int j;

    free_blocks = free_block_lists[i];
    j = 0;
    goto <D.19714>;
    <D.19713>:
    j.193 = (unsigned int) j;
    D.22125 = j.193 * 4;
    D.22126 = free_blocks + D.22125;
    *D.22126 = 0B;
    j = j + 1;
    <D.19714>:
    num_block_obj_sizes.190 = num_block_obj_sizes;
    if (j < num_block_obj_sizes.190) goto <D.19713>; else goto <D.19715>;
    <D.19715>:
  }
  i = i + 1;
  <D.19717>:
  if (i <= 3) goto <D.19716>; else goto <D.19718>;
  <D.19718>:
  iter = &all_blocks;
  goto <D.19732>;
  <D.19731>:
  {
    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.22127 = block->has_pinned;
    has_pinned = (gboolean) D.22127;
    D.22128 = block->pinned;
    block->has_pinned = D.22128;
    block->is_to_space = 0;
    block->swept = 0;
    D.22129 = block->obj_size;
    count = 16368 / D.22129;
    D.22130 = block->cardtable_mod_union;
    if (D.22130 != 0B) goto <D.22131>; else goto <D.22132>;
    <D.22131>:
    D.22130 = block->cardtable_mod_union;
    sgen_free_internal_dynamic (D.22130, 32, 28);
    block->cardtable_mod_union = 0B;
    <D.22132>:
    i = 0;
    goto <D.19727>;
    <D.19726>:
    D.22133 = block->mark_words[i];
    D.22134 = bitcount (D.22133);
    nused = D.22134 + nused;
    i = i + 1;
    <D.19727>:
    i.192 = (unsigned int) i;
    if (i.192 <= 63) goto <D.19726>; else goto <D.19728>;
    <D.19728>:
    if (nused != 0) goto <D.22135>; else goto <D.22136>;
    <D.22135>:
    have_live = 1;
    <D.22136>:
    if (nused < count) goto <D.22137>; else goto <D.22138>;
    <D.22137>:
    have_free = 1;
    <D.22138>:
    lazy_sweep.194 = lazy_sweep;
    if (lazy_sweep.194 == 0) goto <D.22140>; else goto <D.22141>;
    <D.22140>:
    sweep_block (block, 1);
    <D.22141>:
    if (have_live != 0) goto <D.22142>; else goto <D.22143>;
    <D.22142>:
    if (has_pinned == 0) goto <D.22144>; else goto <D.22145>;
    <D.22144>:
    obj_size_index.195 = (unsigned int) obj_size_index;
    D.22147 = obj_size_index.195 * 4;
    D.22148 = num_blocks + D.22147;
    D.22149 = *D.22148;
    D.22150 = D.22149 + 1;
    *D.22148 = D.22150;
    obj_size_index.195 = (unsigned int) obj_size_index;
    D.22147 = obj_size_index.195 * 4;
    D.22151 = slots_used + D.22147;
    obj_size_index.195 = (unsigned int) obj_size_index;
    D.22147 = obj_size_index.195 * 4;
    D.22151 = slots_used + D.22147;
    D.22152 = *D.22151;
    D.22153 = D.22152 + nused;
    *D.22151 = D.22153;
    obj_size_index.195 = (unsigned int) obj_size_index;
    D.22147 = obj_size_index.195 * 4;
    D.22154 = slots_available + D.22147;
    obj_size_index.195 = (unsigned int) obj_size_index;
    D.22147 = obj_size_index.195 * 4;
    D.22154 = slots_available + D.22147;
    D.22155 = *D.22154;
    D.22156 = D.22155 + count;
    *D.22154 = D.22156;
    <D.22145>:
    iter = &block->next;
    if (have_free != 0) goto <D.22157>; else goto <D.22158>;
    <D.22157>:
    {
      struct MSBlockInfo * * free_blocks;
      int index;

      D.22159 = BIT_FIELD_REF <*block, 8, 96>;
      D.22160 = D.22159 & 1;
      D.22161 = D.22160 != 0;
      D.22162 = (int) D.22161;
      D.22159 = BIT_FIELD_REF <*block, 8, 96>;
      D.22163 = (int) D.22159;
      D.22164 = D.22163 & 2;
      D.22165 = D.22162 | D.22164;
      free_blocks = free_block_lists[D.22165];
      D.22129 = block->obj_size;
      D.22167 = D.22129 + 7;
      D.22168 = D.22167 >> 3;
      if (D.22168 <= 31) goto <D.22169>; else goto <D.22170>;
      <D.22169>:
      D.22129 = block->obj_size;
      D.22167 = D.22129 + 7;
      D.22168 = D.22167 >> 3;
      iftmp.196 = fast_block_obj_size_indexes[D.22168];
      goto <D.22171>;
      <D.22170>:
      D.22129 = block->obj_size;
      iftmp.196 = ms_find_block_obj_size_index (D.22129);
      <D.22171>:
      index = iftmp.196;
      index.197 = (unsigned int) index;
      D.22173 = index.197 * 4;
      D.22174 = free_blocks + D.22173;
      D.22175 = *D.22174;
      block->next_free = D.22175;
      index.197 = (unsigned int) index;
      D.22173 = index.197 * 4;
      D.22174 = free_blocks + D.22173;
      *D.22174 = block;
    }
    <D.22158>:
    update_heap_boundaries_for_block (block);
    goto <D.22176>;
    <D.22143>:
    D.22177 = block->next;
    *iter = D.22177;
    D.22178 = block->block;
    ms_free_block (D.22178);
    sgen_free_internal (block, 16);
    num_major_sections.198 = num_major_sections;
    num_major_sections.199 = num_major_sections.198 + -1;
    num_major_sections = num_major_sections.199;
    <D.22176>:
  }
  <D.19732>:
  D.22181 = *iter;
  if (D.22181 != 0B) goto <D.19731>; else goto <D.19733>;
  <D.19733>:
  i = 0;
  goto <D.19737>;
  <D.19736>:
  {
    float usage;

    i.192 = (unsigned int) i;
    D.22118 = i.192 * 4;
    D.22120 = slots_used + D.22118;
    D.22123 = *D.22120;
    D.22182 = (float) D.22123;
    i.192 = (unsigned int) i;
    D.22118 = i.192 * 4;
    D.22119 = slots_available + D.22118;
    D.22183 = *D.22119;
    D.22184 = (float) D.22183;
    usage = D.22182 / D.22184;
    i.192 = (unsigned int) i;
    D.22118 = i.192 * 4;
    D.22121 = num_blocks + D.22118;
    D.22122 = *D.22121;
    if (D.22122 > 5) goto <D.22187>; else goto <D.22185>;
    <D.22187>:
    evacuation_threshold.200 = evacuation_threshold;
    if (usage < evacuation_threshold.200) goto <D.22189>; else goto <D.22185>;
    <D.22189>:
    evacuate_block_obj_sizes.201 = evacuate_block_obj_sizes;
    i.192 = (unsigned int) i;
    D.22118 = i.192 * 4;
    D.22191 = evacuate_block_obj_sizes.201 + D.22118;
    *D.22191 = 1;
    goto <D.22186>;
    <D.22185>:
    evacuate_block_obj_sizes.201 = evacuate_block_obj_sizes;
    i.192 = (unsigned int) i;
    D.22118 = i.192 * 4;
    D.22191 = evacuate_block_obj_sizes.201 + D.22118;
    *D.22191 = 0;
    <D.22186>:
    {
      mword total_bytes;

      block_obj_sizes.202 = block_obj_sizes;
      i.192 = (unsigned int) i;
      D.22118 = i.192 * 4;
      D.22193 = block_obj_sizes.202 + D.22118;
      D.22194 = *D.22193;
      i.192 = (unsigned int) i;
      D.22118 = i.192 * 4;
      D.22119 = slots_available + D.22118;
      D.22183 = *D.22119;
      D.22195 = D.22194 * D.22183;
      total_bytes = (mword) D.22195;
      total_evacuate_heap = total_evacuate_heap + total_bytes;
      evacuate_block_obj_sizes.201 = evacuate_block_obj_sizes;
      i.192 = (unsigned int) i;
      D.22118 = i.192 * 4;
      D.22191 = evacuate_block_obj_sizes.201 + D.22118;
      D.22196 = *D.22191;
      if (D.22196 != 0) goto <D.22197>; else goto <D.22198>;
      <D.22197>:
      block_obj_sizes.202 = block_obj_sizes;
      i.192 = (unsigned int) i;
      D.22118 = i.192 * 4;
      D.22193 = block_obj_sizes.202 + D.22118;
      D.22194 = *D.22193;
      i.192 = (unsigned int) i;
      D.22118 = i.192 * 4;
      D.22120 = slots_used + D.22118;
      D.22123 = *D.22120;
      D.22199 = D.22194 * D.22123;
      D.22200 = (unsigned int) D.22199;
      D.22201 = total_bytes - D.22200;
      total_evacuate_saved = D.22201 + total_evacuate_saved;
      <D.22198>:
    }
  }
  i = i + 1;
  <D.19737>:
  num_block_obj_sizes.190 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.190) goto <D.19736>; else goto <D.19738>;
  <D.19738>:
  D.22202 = (float) total_evacuate_saved;
  D.22203 = (float) total_evacuate_heap;
  D.22204 = D.22202 / D.22203;
  concurrent_evacuation_threshold.203 = concurrent_evacuation_threshold;
  D.22206 = 1.0e+0 - concurrent_evacuation_threshold.203;
  D.22207 = D.22204 > D.22206;
  want_evacuation.204 = (int) D.22207;
  want_evacuation = want_evacuation.204;
  have_swept = 1;
}


bitcount (mword d)
{
  int D.22211;
  int D.22213;
  int D.22214;
  int count;

  count = 0;
  if (1 != 0) goto <D.22209>; else goto <D.22210>;
  <D.22209>:
  D.22211 = __builtin_popcountl (d);
  count = D.22211 + count;
  goto <D.22212>;
  <D.22210>:
  D.22213 = __builtin_popcount (d);
  count = D.22213 + count;
  <D.22212>:
  D.22214 = count;
  return D.22214;
}


update_heap_boundaries_for_block (struct MSBlockInfo * block)
{
  char * D.22216;
  unsigned int D.22217;
  unsigned int D.22218;

  D.22216 = block->block;
  D.22217 = (unsigned int) D.22216;
  D.22218 = D.22217 + 16384;
  D.22216 = block->block;
  D.22217 = (unsigned int) D.22216;
  sgen_update_heap_boundaries (D.22217, D.22218);
}


ms_free_block (void * block)
{
  void * D.22219;
  int D.22220;
  int D.22221;
  void * empty;

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

    <D.19062>:
    __old_x = num_empty_blocks;
    D.22220 = __old_x + 1;
    D.22221 = InterlockedCompareExchange (&num_empty_blocks, D.22220, __old_x);
    if (D.22221 != __old_x) goto <D.19062>; else goto <D.19063>;
    <D.19063>:
  }
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.22222;
  unsigned int exch.205;
  unsigned int comp.206;
  unsigned int D.22225;

  exch.205 = (unsigned int) exch;
  comp.206 = (unsigned int) comp;
  D.22225 = __sync_val_compare_and_swap_4 (dest, comp.206, exch.205);
  D.22222 = (void *) D.22225;
  return D.22222;
}


InterlockedCompareExchange (volatile gint32 * dest, gint32 exch, gint32 comp)
{
  gint32 D.22227;
  unsigned int exch.207;
  unsigned int comp.208;
  unsigned int D.22230;

  exch.207 = (unsigned int) exch;
  comp.208 = (unsigned int) comp;
  D.22230 = __sync_val_compare_and_swap_4 (dest, comp.208, exch.207);
  D.22227 = (gint32) D.22230;
  return D.22227;
}


major_init_to_space ()
{

}


major_get_cardtable_mod_union_for_object (char * obj)
{
  unsigned int obj.209;
  unsigned int D.22233;
  struct MSBlockHeader * D.22234;
  guint8 * D.22235;
  guint8 * D.22236;
  int obj.210;
  char * D.22238;
  void * D.22239;
  int D.22240;
  int D.22241;
  int D.22242;
  sizetype D.22243;
  struct MSBlockInfo * block;

  obj.209 = (unsigned int) obj;
  D.22233 = obj.209 & 4294950912;
  D.22234 = (struct MSBlockHeader *) D.22233;
  block = D.22234->info;
  D.22236 = block->cardtable_mod_union;
  obj.210 = (int) obj;
  D.22238 = block->block;
  D.22239 = sgen_card_table_align_pointer (D.22238);
  D.22240 = (int) D.22239;
  D.22241 = obj.210 - D.22240;
  D.22242 = D.22241 >> 9;
  D.22243 = (sizetype) D.22242;
  D.22235 = D.22236 + D.22243;
  return D.22235;
}


update_cardtable_mod_union ()
{
  char * D.22245;
  guint8 * D.22246;
  guint8 * D.22247;
  unsigned int num_cards.211;
  _Bool D.22249;
  long int D.22250;
  long int D.22251;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.19985>;
  <D.19984>:
  {
    size_t num_cards;

    try
      {
        D.22245 = block->block;
        D.22246 = block->cardtable_mod_union;
        D.22247 = sgen_card_table_update_mod_union (D.22246, D.22245, 16384, &num_cards);
        block->cardtable_mod_union = D.22247;
        num_cards.211 = num_cards;
        D.22249 = num_cards.211 != 32;
        D.22250 = (long int) D.22249;
        D.22251 = __builtin_expect (D.22250, 0);
        if (D.22251 != 0) goto <D.22252>; else goto <D.22253>;
        <D.22252>:
        monoeg_g_log (0B, 4, "Number of cards calculation is wrong");
        <D.19983>:
        goto <D.19983>;
        <D.22253>:
      }
    finally
      {
        num_cards = {CLOBBER};
      }
  }
  block = block->next;
  <D.19985>:
  if (block != 0B) goto <D.19984>; else goto <D.19986>;
  <D.19986>:
}


major_iterate_live_block_ranges (void (*sgen_cardtable_block_callback) (mword, mword) callback)
{
  unsigned char D.22254;
  unsigned char D.22255;
  char * D.22258;
  unsigned int D.22259;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.19915>;
  <D.19914>:
  D.22254 = BIT_FIELD_REF <*block, 8, 96>;
  D.22255 = D.22254 & 2;
  if (D.22255 != 0) goto <D.22256>; else goto <D.22257>;
  <D.22256>:
  D.22258 = block->block;
  D.22259 = (unsigned int) D.22258;
  callback (D.22259, 16384);
  <D.22257>:
  block = block->next;
  <D.19915>:
  if (block != 0B) goto <D.19914>; else goto <D.19916>;
  <D.19916>:
}


major_scan_card_table (gboolean mod_union, struct SgenGrayQueue * queue)
{
  struct SgenObjectOperations * D.22260;
  int concurrent_mark.212;
  _Bool D.22264;
  long int D.22265;
  long int D.22266;
  unsigned char D.22269;
  unsigned char D.22270;
  unsigned int block_start.213;
  int D.22281;
  unsigned char D.22284;
  void * D.22288;
  char * D.22290;
  char * D.22292;
  int obj.214;
  int obj.215;
  int D.22297;
  int D.22298;
  unsigned int D.22302;
  long int D.22303;
  long unsigned int D.22304;
  long unsigned int D.22305;
  int base.216;
  int D.22308;
  sizetype card_offset.217;
  guint8 * D.22310;
  unsigned int block_obj_size.218;
  sizetype block_obj_size.219;
  int card_data.220;
  int card_base.221;
  int D.22321;
  sizetype D.22322;
  unsigned char D.22323;
  int start.222;
  char * D.22332;
  int D.22333;
  int D.22334;
  int D.22335;
  sizetype D.22336;
  sizetype D.22337;
  void * D.22339;
  char * D.22341;
  int obj.223;
  int obj.224;
  int D.22347;
  int D.22348;
  unsigned int D.22352;
  long int D.22353;
  long unsigned int D.22354;
  long unsigned int D.22355;
  struct MSBlockInfo * block;
  void (*ScanObjectFunc) (char *, struct SgenGrayQueue *) scan_func;
  void next_large = <<< error >>>;
  void next_small = <<< error >>>;

  D.22260 = sgen_get_current_object_ops ();
  scan_func = D.22260->scan_object;
  concurrent_mark.212 = concurrent_mark;
  if (concurrent_mark.212 == 0) goto <D.22262>; else goto <D.22263>;
  <D.22262>:
  D.22264 = mod_union != 0;
  D.22265 = (long int) D.22264;
  D.22266 = __builtin_expect (D.22265, 0);
  if (D.22266 != 0) goto <D.22267>; else goto <D.22268>;
  <D.22267>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 2225, "!mod_union");
  <D.22268>:
  <D.22263>:
  block = all_blocks;
  goto <D.19976>;
  <D.19975>:
  {
    int block_obj_size;
    char * block_start;

    D.22269 = BIT_FIELD_REF <*block, 8, 96>;
    D.22270 = D.22269 & 2;
    if (D.22270 == 0) goto <D.22271>; else goto <D.22272>;
    <D.22271>:
    // predicted unlikely by continue predictor.
    goto <D.19941>;
    <D.22272>:
    block_obj_size = block->obj_size;
    block_start = block->block;
    if (block_obj_size > 511) goto <D.22273>; else goto <D.22274>;
    <D.22273>:
    {
      guint8 * cards;
      guint8 cards_data[32];
      char * obj;
      char * end;
      char * base;

      try
        {
          if (mod_union != 0) goto <D.22275>; else goto <D.22276>;
          <D.22275>:
          cards = block->cardtable_mod_union;
          if (cards == 0B) goto <D.22277>; else goto <D.22278>;
          <D.22277>:
          // predicted unlikely by continue predictor.
          goto <D.19941>;
          <D.22278>:
          goto <D.22279>;
          <D.22276>:
          cards = &cards_data;
          block_start.213 = (unsigned int) block_start;
          D.22281 = sgen_card_table_get_card_data (&cards_data, block_start.213, 32);
          if (D.22281 == 0) goto <D.22282>; else goto <D.22283>;
          <D.22282>:
          // predicted unlikely by continue predictor.
          goto <D.19941>;
          <D.22283>:
          <D.22279>:
          obj = block_start + 16;
          end = block_start + 16384;
          base = sgen_card_table_align_pointer (obj);
          goto <D.19953>;
          <D.19952>:
          {
            int card_offset;

            D.22269 = BIT_FIELD_REF <*block, 8, 96>;
            D.22284 = D.22269 & 16;
            if (D.22284 == 0) goto <D.22285>; else goto <D.22286>;
            <D.22285>:
            sweep_block (block, 0);
            <D.22286>:
            D.22288 = MEM[(void * *)obj];
            if (D.22288 == 0B) goto next_large; else goto <D.22289>;
            <D.22289>:
            D.22290 = MEM[(char * *)obj];
            if (D.22290 >= block_start) goto <D.22291>; else goto <D.22287>;
            <D.22291>:
            D.22290 = MEM[(char * *)obj];
            D.22292 = block_start + 16384;
            if (D.22290 < D.22292) goto next_large; else goto <D.22287>;
            <D.22287>:
            if (mod_union != 0) goto <D.22293>; else goto <D.22294>;
            <D.22293>:
            {
              int w;
              int b;

              {
                int i;

                obj.214 = (int) obj;
                obj.215 = (int) obj;
                D.22297 = obj.215 & -16384;
                D.22298 = obj.214 - D.22297;
                i = D.22298 >> 3;
                if (1 != 0) goto <D.22299>; else goto <D.22300>;
                <D.22299>:
                w = i >> 5;
                b = i & 31;
                goto <D.22301>;
                <D.22300>:
                w = i >> 6;
                b = i & 63;
                <D.22301>:
              }
              D.22302 = block->mark_words[w];
              D.22303 = 1 << b;
              D.22304 = (long unsigned int) D.22303;
              D.22305 = D.22302 & D.22304;
              if (D.22305 == 0) goto next_large; else goto <D.22306>;
              <D.22306>:
            }
            <D.22294>:
            obj.214 = (int) obj;
            base.216 = (int) base;
            D.22308 = obj.214 - base.216;
            card_offset = D.22308 >> 9;
            card_offset.217 = (sizetype) card_offset;
            D.22310 = cards + card_offset.217;
            block_obj_size.218 = (unsigned int) block_obj_size;
            sgen_cardtable_scan_object (obj, block_obj_size.218, D.22310, mod_union, queue);
            next_large:
            block_obj_size.219 = (sizetype) block_obj_size;
            obj = obj + block_obj_size.219;
          }
          <D.19953>:
          if (obj < end) goto <D.19952>; else goto <D.19954>;
          <D.19954>:
        }
      finally
        {
          cards_data = {CLOBBER};
        }
    }
    goto <D.22313>;
    <D.22274>:
    {
      guint8 * card_data;
      guint8 * card_base;
      guint8 * card_data_end;

      if (mod_union != 0) goto <D.22314>; else goto <D.22315>;
      <D.22314>:
      card_base = block->cardtable_mod_union;
      card_data = card_base;
      if (card_data == 0B) goto <D.22316>; else goto <D.22317>;
      <D.22316>:
      // predicted unlikely by continue predictor.
      goto <D.19941>;
      <D.22317>:
      goto <D.22318>;
      <D.22315>:
      block_start.213 = (unsigned int) block_start;
      card_base = sgen_card_table_get_card_address (block_start.213);
      card_data = card_base;
      <D.22318>:
      card_data_end = card_data + 32;
      card_data = initial_skip_card (card_data);
      goto <D.19973>;
      <D.19972>:
      {
        int index;
        int idx;
        char * start;
        char * end;
        char * first_obj;
        char * obj;

        card_data.220 = (int) card_data;
        card_base.221 = (int) card_base;
        idx = card_data.220 - card_base.221;
        D.22321 = idx * 512;
        D.22322 = (sizetype) D.22321;
        start = block_start + D.22322;
        end = start + 512;
        D.22323 = *card_data;
        if (D.22323 == 0) goto <D.22324>; else goto <D.22325>;
        <D.22324>:
        // predicted unlikely by continue predictor.
        goto <D.19964>;
        <D.22325>:
        D.22269 = BIT_FIELD_REF <*block, 8, 96>;
        D.22284 = D.22269 & 16;
        if (D.22284 == 0) goto <D.22326>; else goto <D.22327>;
        <D.22326>:
        sweep_block (block, 0);
        <D.22327>:
        sgen_card_table_prepare_card_for_scanning (card_data);
        if (idx == 0) goto <D.22328>; else goto <D.22329>;
        <D.22328>:
        index = 0;
        goto <D.22330>;
        <D.22329>:
        start.222 = (int) start;
        D.22332 = block_start + 16;
        D.22333 = (int) D.22332;
        D.22334 = start.222 - D.22333;
        index = D.22334 / block_obj_size;
        <D.22330>:
        D.22335 = block_obj_size * index;
        D.22336 = (sizetype) D.22335;
        D.22337 = D.22336 + 16;
        first_obj = block_start + D.22337;
        obj = first_obj;
        goto <D.19970>;
        <D.19969>:
        D.22339 = MEM[(void * *)obj];
        if (D.22339 == 0B) goto next_small; else goto <D.22340>;
        <D.22340>:
        D.22341 = MEM[(char * *)obj];
        if (D.22341 >= block_start) goto <D.22342>; else goto <D.22338>;
        <D.22342>:
        D.22341 = MEM[(char * *)obj];
        D.22292 = block_start + 16384;
        if (D.22341 < D.22292) goto next_small; else goto <D.22338>;
        <D.22338>:
        if (mod_union != 0) goto <D.22343>; else goto <D.22344>;
        <D.22343>:
        {
          int w;
          int b;

          {
            int i;

            obj.223 = (int) obj;
            obj.224 = (int) obj;
            D.22347 = obj.224 & -16384;
            D.22348 = obj.223 - D.22347;
            i = D.22348 >> 3;
            if (1 != 0) goto <D.22349>; else goto <D.22350>;
            <D.22349>:
            w = i >> 5;
            b = i & 31;
            goto <D.22351>;
            <D.22350>:
            w = i >> 6;
            b = i & 63;
            <D.22351>:
          }
          D.22352 = block->mark_words[w];
          D.22353 = 1 << b;
          D.22354 = (long unsigned int) D.22353;
          D.22355 = D.22352 & D.22354;
          if (D.22355 == 0) goto next_small; else goto <D.22356>;
          <D.22356>:
        }
        <D.22344>:
        scan_func (obj, queue);
        next_small:
        block_obj_size.219 = (sizetype) block_obj_size;
        obj = obj + block_obj_size.219;
        <D.19970>:
        if (obj < end) goto <D.19969>; else goto <D.19971>;
        <D.19971>:
      }
      <D.19964>:
      card_data = card_data + 1;
      <D.19973>:
      if (card_data < card_data_end) goto <D.19972>; else goto <D.19974>;
      <D.19974>:
    }
    <D.22313>:
  }
  <D.19941>:
  block = block->next;
  <D.19976>:
  if (block != 0B) goto <D.19975>; else goto <D.19977>;
  <D.19977>:
}


sgen_card_table_get_card_address (mword address)
{
  guint8 * D.22359;
  guint8 * sgen_cardtable.225;
  unsigned int D.22361;

  sgen_cardtable.225 = sgen_cardtable;
  D.22361 = address >> 9;
  D.22359 = sgen_cardtable.225 + D.22361;
  return D.22359;
}


initial_skip_card (guint8 * card_data)
{
  unsigned int i.226;
  unsigned int D.22364;
  mword * D.22365;
  guint8 * D.22369;
  int D.22370;
  sizetype D.22371;
  int card.227;
  int D.22373;
  int D.22374;
  int D.22375;
  sizetype D.22376;
  sizetype D.22377;
  mword * cards;
  mword card;
  int i;

  cards = card_data;
  i = 0;
  goto <D.19925>;
  <D.19924>:
  i.226 = (unsigned int) i;
  D.22364 = i.226 * 4;
  D.22365 = cards + D.22364;
  card = *D.22365;
  if (card != 0) goto <D.19923>; else goto <D.22366>;
  <D.22366>:
  i = i + 1;
  <D.19925>:
  if (i <= 7) goto <D.19924>; else goto <D.19923>;
  <D.19923>:
  if (i == 8) goto <D.22367>; else goto <D.22368>;
  <D.22367>:
  D.22369 = card_data + 32;
  return D.22369;
  <D.22368>:
  D.22370 = i * 4;
  D.22371 = (sizetype) D.22370;
  card.227 = (int) card;
  D.22373 = __builtin_ffs (card.227);
  D.22374 = D.22373 + -1;
  D.22375 = D.22374 / 8;
  D.22376 = (sizetype) D.22375;
  D.22377 = D.22371 + D.22376;
  D.22369 = card_data + D.22377;
  return D.22369;
}


sgen_card_table_prepare_card_for_scanning (guint8 * card)
{
  *card = 0;
}


pin_major_object (char * obj, struct SgenGrayQueue * queue)
{
  int concurrent_mark.228;
  unsigned int obj.229;
  unsigned int D.22383;
  struct MSBlockHeader * D.22384;
  int obj.230;
  int obj.231;
  int D.22387;
  int D.22388;
  unsigned int D.22394;
  long int D.22395;
  long unsigned int D.22396;
  long unsigned int D.22397;
  long unsigned int D.22400;
  unsigned char D.22401;
  unsigned char D.22402;
  int iftmp.232;
  struct GrayQueueSection * D.22409;
  int D.22411;
  _Bool D.22412;
  long int D.22413;
  long int D.22414;
  int D.22418;
  int D.22419;
  struct MSBlockInfo * block;

  concurrent_mark.228 = concurrent_mark;
  if (concurrent_mark.228 != 0) goto <D.22380>; else goto <D.22381>;
  <D.22380>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-marksweep.c", 1107);
  <D.22381>:
  obj.229 = (unsigned int) obj;
  D.22383 = obj.229 & 4294950912;
  D.22384 = (struct MSBlockHeader *) D.22383;
  block = D.22384->info;
  block->has_pinned = 1;
  {
    int __word;
    int __bit;

    {
      int i;

      obj.230 = (int) obj;
      obj.231 = (int) obj;
      D.22387 = obj.231 & -16384;
      D.22388 = obj.230 - D.22387;
      i = D.22388 >> 3;
      if (1 != 0) goto <D.22389>; else goto <D.22390>;
      <D.22389>:
      __word = i >> 5;
      __bit = i & 31;
      goto <D.22391>;
      <D.22390>:
      __word = i >> 6;
      __bit = i & 63;
      <D.22391>:
    }
    if (0 != 0) goto <D.22392>; else goto <D.22393>;
    <D.22392>:
    monoeg_g_log (0B, 4, "object %p not allocated", obj);
    <D.19251>:
    goto <D.19251>;
    <D.22393>:
    D.22394 = block->mark_words[__word];
    D.22395 = 1 << __bit;
    D.22396 = (long unsigned int) D.22395;
    D.22397 = D.22394 & D.22396;
    if (D.22397 == 0) goto <D.22398>; else goto <D.22399>;
    <D.22398>:
    D.22394 = block->mark_words[__word];
    D.22395 = 1 << __bit;
    D.22396 = (long unsigned int) D.22395;
    D.22400 = D.22394 | D.22396;
    block->mark_words[__word] = D.22400;
    D.22401 = BIT_FIELD_REF <*block, 8, 96>;
    D.22402 = D.22401 & 2;
    if (D.22402 != 0) goto <D.22403>; else goto <D.22404>;
    <D.22403>:
    D.22409 = queue->first;
    if (D.22409 == 0B) goto <D.22406>; else goto <D.22410>;
    <D.22410>:
    D.22409 = queue->first;
    D.22411 = D.22409->end;
    if (D.22411 == 125) goto <D.22406>; else goto <D.22407>;
    <D.22406>:
    iftmp.232 = 1;
    goto <D.22408>;
    <D.22407>:
    iftmp.232 = 0;
    <D.22408>:
    D.22412 = iftmp.232 != 0;
    D.22413 = (long int) D.22412;
    D.22414 = __builtin_expect (D.22413, 0);
    if (D.22414 != 0) goto <D.22415>; else goto <D.22416>;
    <D.22415>:
    sgen_gray_object_enqueue (queue, obj);
    goto <D.22417>;
    <D.22416>:
    D.22409 = queue->first;
    D.22409 = queue->first;
    D.22411 = D.22409->end;
    D.22418 = D.22411;
    D.22419 = D.22418 + 1;
    D.22409->end = D.22419;
    D.22409->objects[D.22418] = obj;
    <D.22417>:
    __builtin_prefetch (obj);
    <D.22404>:
    <D.22399>:
  }
}


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

  block = all_blocks;
  goto <D.19860>;
  <D.19859>:
  mark_pinned_objects_in_block (block, queue);
  block = block->next;
  <D.19860>:
  if (block != 0B) goto <D.19859>; else goto <D.19861>;
  <D.19861>:
}


mark_pinned_objects_in_block (struct MSBlockInfo * block, struct SgenGrayQueue * queue)
{
  int D.22420;
  void * * D.22423;
  unsigned int i.233;
  unsigned int D.22425;
  void * * D.22426;
  void * D.22427;
  int D.22428;
  char * D.22429;
  char * D.22430;
  int D.22431;
  int D.22432;
  int D.22433;
  int D.22436;
  int D.22439;
  sizetype D.22440;
  sizetype D.22441;
  char * D.22442;
  int D.22443;
  int D.22444;
  int D.22445;
  int D.22446;
  unsigned int D.22452;
  long int D.22453;
  long unsigned int D.22454;
  long unsigned int D.22455;
  void * D.22458;
  char * D.22461;
  char * D.22463;
  long unsigned int D.22464;
  unsigned char D.22465;
  unsigned char D.22466;
  int iftmp.234;
  struct GrayQueueSection * D.22473;
  int D.22475;
  _Bool D.22476;
  long int D.22477;
  long int D.22478;
  int D.22482;
  int D.22483;
  int i;
  int last_index;

  last_index = -1;
  D.22420 = block->pin_queue_num_entries;
  if (D.22420 == 0) goto <D.22421>; else goto <D.22422>;
  <D.22421>:
  return;
  <D.22422>:
  block->has_pinned = 1;
  i = 0;
  goto <D.19665>;
  <D.19664>:
  {
    int index;

    D.22423 = block->pin_queue_start;
    i.233 = (unsigned int) i;
    D.22425 = i.233 * 4;
    D.22426 = D.22423 + D.22425;
    D.22427 = *D.22426;
    D.22428 = (int) D.22427;
    D.22429 = block->block;
    D.22430 = D.22429 + 16;
    D.22431 = (int) D.22430;
    D.22432 = D.22428 - D.22431;
    D.22433 = block->obj_size;
    index = D.22432 / D.22433;
    if (0 != 0) goto <D.22434>; else goto <D.22435>;
    <D.22434>:
    D.22433 = block->obj_size;
    D.22436 = 16368 / D.22433;
    D.22423 = block->pin_queue_start;
    i.233 = (unsigned int) i;
    D.22425 = i.233 * 4;
    D.22426 = D.22423 + D.22425;
    D.22427 = *D.22426;
    monoeg_g_log (0B, 4, "invalid object %p index %d max-index %d", D.22427, index, D.22436);
    <D.19659>:
    goto <D.19659>;
    <D.22435>:
    if (index == last_index) goto <D.22437>; else goto <D.22438>;
    <D.22437>:
    // predicted unlikely by continue predictor.
    goto <D.19660>;
    <D.22438>:
    {
      int __word;
      int __bit;

      {
        int i;

        D.22429 = block->block;
        D.22433 = block->obj_size;
        D.22439 = D.22433 * index;
        D.22440 = (sizetype) D.22439;
        D.22441 = D.22440 + 16;
        D.22442 = D.22429 + D.22441;
        D.22443 = (int) D.22442;
        D.22429 = block->block;
        D.22433 = block->obj_size;
        D.22439 = D.22433 * index;
        D.22440 = (sizetype) D.22439;
        D.22441 = D.22440 + 16;
        D.22442 = D.22429 + D.22441;
        D.22444 = (int) D.22442;
        D.22445 = D.22444 & -16384;
        D.22446 = D.22443 - D.22445;
        i = D.22446 >> 3;
        if (1 != 0) goto <D.22447>; else goto <D.22448>;
        <D.22447>:
        __word = i >> 5;
        __bit = i & 31;
        goto <D.22449>;
        <D.22448>:
        __word = i >> 6;
        __bit = i & 63;
        <D.22449>:
      }
      D.22452 = block->mark_words[__word];
      D.22453 = 1 << __bit;
      D.22454 = (long unsigned int) D.22453;
      D.22455 = D.22452 & D.22454;
      if (D.22455 == 0) goto <D.22456>; else goto <D.22457>;
      <D.22456>:
      D.22429 = block->block;
      D.22433 = block->obj_size;
      D.22439 = D.22433 * index;
      D.22440 = (sizetype) D.22439;
      D.22441 = D.22440 + 16;
      D.22442 = D.22429 + D.22441;
      D.22458 = MEM[(void * *)D.22442];
      if (D.22458 != 0B) goto <D.22459>; else goto <D.22460>;
      <D.22459>:
      D.22429 = block->block;
      D.22433 = block->obj_size;
      D.22439 = D.22433 * index;
      D.22440 = (sizetype) D.22439;
      D.22441 = D.22440 + 16;
      D.22442 = D.22429 + D.22441;
      D.22461 = MEM[(char * *)D.22442];
      D.22429 = block->block;
      if (D.22461 < D.22429) goto <D.22450>; else goto <D.22462>;
      <D.22462>:
      D.22429 = block->block;
      D.22433 = block->obj_size;
      D.22439 = D.22433 * index;
      D.22440 = (sizetype) D.22439;
      D.22441 = D.22440 + 16;
      D.22442 = D.22429 + D.22441;
      D.22461 = MEM[(char * *)D.22442];
      D.22429 = block->block;
      D.22463 = D.22429 + 16384;
      if (D.22461 >= D.22463) goto <D.22450>; else goto <D.22451>;
      <D.22450>:
      D.22452 = block->mark_words[__word];
      D.22453 = 1 << __bit;
      D.22454 = (long unsigned int) D.22453;
      D.22464 = D.22452 | D.22454;
      block->mark_words[__word] = D.22464;
      D.22465 = BIT_FIELD_REF <*block, 8, 96>;
      D.22466 = D.22465 & 2;
      if (D.22466 != 0) goto <D.22467>; else goto <D.22468>;
      <D.22467>:
      D.22473 = queue->first;
      if (D.22473 == 0B) goto <D.22470>; else goto <D.22474>;
      <D.22474>:
      D.22473 = queue->first;
      D.22475 = D.22473->end;
      if (D.22475 == 125) goto <D.22470>; else goto <D.22471>;
      <D.22470>:
      iftmp.234 = 1;
      goto <D.22472>;
      <D.22471>:
      iftmp.234 = 0;
      <D.22472>:
      D.22476 = iftmp.234 != 0;
      D.22477 = (long int) D.22476;
      D.22478 = __builtin_expect (D.22477, 0);
      if (D.22478 != 0) goto <D.22479>; else goto <D.22480>;
      <D.22479>:
      D.22429 = block->block;
      D.22433 = block->obj_size;
      D.22439 = D.22433 * index;
      D.22440 = (sizetype) D.22439;
      D.22441 = D.22440 + 16;
      D.22442 = D.22429 + D.22441;
      sgen_gray_object_enqueue (queue, D.22442);
      goto <D.22481>;
      <D.22480>:
      D.22473 = queue->first;
      D.22473 = queue->first;
      D.22475 = D.22473->end;
      D.22482 = D.22475;
      D.22483 = D.22482 + 1;
      D.22473->end = D.22483;
      D.22429 = block->block;
      D.22433 = block->obj_size;
      D.22439 = D.22433 * index;
      D.22440 = (sizetype) D.22439;
      D.22441 = D.22440 + 16;
      D.22442 = D.22429 + D.22441;
      D.22473->objects[D.22482] = D.22442;
      <D.22481>:
      D.22429 = block->block;
      D.22433 = block->obj_size;
      D.22439 = D.22433 * index;
      D.22440 = (sizetype) D.22439;
      D.22441 = D.22440 + 16;
      D.22442 = D.22429 + D.22441;
      __builtin_prefetch (D.22442);
      <D.22468>:
      <D.22451>:
      <D.22460>:
      <D.22457>:
    }
    last_index = index;
  }
  <D.19660>:
  i = i + 1;
  <D.19665>:
  D.22420 = block->pin_queue_num_entries;
  if (D.22420 > i) goto <D.19664>; else goto <D.19666>;
  <D.19666>:
}


major_find_pin_queue_start_ends (struct SgenGrayQueue * queue)
{
  int * D.22485;
  char * D.22486;
  void * D.22487;
  void * D.22488;
  void * * D.22489;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.19853>;
  <D.19852>:
  D.22485 = &block->pin_queue_num_entries;
  D.22486 = block->block;
  D.22487 = D.22486 + 16384;
  D.22486 = block->block;
  D.22488 = D.22486 + 16;
  D.22489 = sgen_find_optimized_pin_queue_area (D.22488, D.22487, D.22485);
  block->pin_queue_start = D.22489;
  block = block->next;
  <D.19853>:
  if (block != 0B) goto <D.19852>; else goto <D.19854>;
  <D.19854>:
}


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


free_object (char * obj, size_t size, gboolean pinned)
{
  unsigned int obj.235;
  unsigned int D.22491;
  struct MSBlockHeader * D.22492;
  unsigned char D.22493;
  unsigned char D.22494;
  <unnamed-unsigned:1> D.22499;
  int D.22500;
  int obj.236;
  int obj.237;
  int D.22505;
  int D.22506;
  void * * D.22512;
  _Bool D.22515;
  int D.22516;
  int D.22517;
  int D.22518;
  int D.22519;
  int iftmp.238;
  unsigned int D.22521;
  unsigned int D.22522;
  int size.239;
  unsigned int size_index.240;
  unsigned int D.22530;
  struct MSBlockInfo * * D.22531;
  struct MSBlockInfo * D.22532;
  struct MSBlockInfo * block;
  int word;
  int bit;

  obj.235 = (unsigned int) obj;
  D.22491 = obj.235 & 4294950912;
  D.22492 = (struct MSBlockHeader *) D.22491;
  block = D.22492->info;
  D.22493 = BIT_FIELD_REF <*block, 8, 96>;
  D.22494 = D.22493 & 16;
  if (D.22494 == 0) goto <D.22495>; else goto <D.22496>;
  <D.22495>:
  sweep_block (block, 0);
  <D.22496>:
  if (0 != 0) goto <D.22497>; else goto <D.22498>;
  <D.22497>:
  D.22499 = block->pinned;
  D.22500 = (int) D.22499;
  monoeg_g_log (0B, 4, "free-object pinning mixup object %p pinned %d block %p pinned %d", obj, pinned, block, D.22500);
  <D.19118>:
  goto <D.19118>;
  <D.22498>:
  if (0 != 0) goto <D.22501>; else goto <D.22502>;
  <D.22501>:
  monoeg_g_log (0B, 4, "object %p is already free", obj);
  <D.19119>:
  goto <D.19119>;
  <D.22502>:
  {
    int i;

    obj.236 = (int) obj;
    obj.237 = (int) obj;
    D.22505 = obj.237 & -16384;
    D.22506 = obj.236 - D.22505;
    i = D.22506 >> 3;
    if (1 != 0) goto <D.22507>; else goto <D.22508>;
    <D.22507>:
    word = i >> 5;
    bit = i & 31;
    goto <D.22509>;
    <D.22508>:
    word = i >> 6;
    bit = i & 63;
    <D.22509>:
  }
  if (0 != 0) goto <D.22510>; else goto <D.22511>;
  <D.22510>:
  monoeg_g_log (0B, 4, "object %p has mark bit set");
  <D.19121>:
  goto <D.19121>;
  <D.22511>:
  D.22512 = block->free_list;
  if (D.22512 == 0B) goto <D.22513>; else goto <D.22514>;
  <D.22513>:
  {
    struct MSBlockInfo * * free_blocks;
    int size_index;

    D.22515 = pinned != 0;
    D.22516 = (int) D.22515;
    D.22493 = BIT_FIELD_REF <*block, 8, 96>;
    D.22517 = (int) D.22493;
    D.22518 = D.22517 & 2;
    D.22519 = D.22516 | D.22518;
    free_blocks = free_block_lists[D.22519];
    D.22521 = size + 7;
    D.22522 = D.22521 >> 3;
    if (D.22522 <= 31) goto <D.22523>; else goto <D.22524>;
    <D.22523>:
    D.22521 = size + 7;
    D.22522 = D.22521 >> 3;
    iftmp.238 = fast_block_obj_size_indexes[D.22522];
    goto <D.22525>;
    <D.22524>:
    size.239 = (int) size;
    iftmp.238 = ms_find_block_obj_size_index (size.239);
    <D.22525>:
    size_index = iftmp.238;
    if (0 != 0) goto <D.22527>; else goto <D.22528>;
    <D.22527>:
    monoeg_g_log (0B, 4, "block %p doesn\'t have a free-list of object but belongs to a free-list of blocks");
    <D.19124>:
    goto <D.19124>;
    <D.22528>:
    size_index.240 = (unsigned int) size_index;
    D.22530 = size_index.240 * 4;
    D.22531 = free_blocks + D.22530;
    D.22532 = *D.22531;
    block->next_free = D.22532;
    size_index.240 = (unsigned int) size_index;
    D.22530 = size_index.240 * 4;
    D.22531 = free_blocks + D.22530;
    *D.22531 = block;
  }
  <D.22514>:
  memset (obj, 0, size);
  D.22512 = block->free_list;
  MEM[(void * *)obj] = D.22512;
  block->free_list = obj;
}


major_iterate_objects (gboolean non_pinned, gboolean pinned, void (*IterateObjectCallbackFunc) (char *, size_t, void *) callback, void * data)
{
  int D.22533;
  unsigned char D.22534;
  unsigned char D.22535;
  int lazy_sweep.241;
  char * D.22547;
  int D.22548;
  sizetype D.22549;
  sizetype D.22550;
  void * D.22553;
  char * D.22556;
  char * D.22558;
  unsigned int D.22559;
  struct MSBlockInfo * block;

  block = all_blocks;
  goto <D.19182>;
  <D.19181>:
  {
    int count;
    int i;

    D.22533 = block->obj_size;
    count = 16368 / D.22533;
    D.22534 = BIT_FIELD_REF <*block, 8, 96>;
    D.22535 = D.22534 & 1;
    if (D.22535 != 0) goto <D.22536>; else goto <D.22537>;
    <D.22536>:
    if (pinned == 0) goto <D.22538>; else goto <D.22539>;
    <D.22538>:
    // predicted unlikely by continue predictor.
    goto <D.19176>;
    <D.22539>:
    <D.22537>:
    D.22534 = BIT_FIELD_REF <*block, 8, 96>;
    D.22535 = D.22534 & 1;
    if (D.22535 == 0) goto <D.22540>; else goto <D.22541>;
    <D.22540>:
    if (non_pinned == 0) goto <D.22542>; else goto <D.22543>;
    <D.22542>:
    // predicted unlikely by continue predictor.
    goto <D.19176>;
    <D.22543>:
    <D.22541>:
    lazy_sweep.241 = lazy_sweep;
    if (lazy_sweep.241 != 0) goto <D.22545>; else goto <D.22546>;
    <D.22545>:
    sweep_block (block, 0);
    <D.22546>:
    i = 0;
    goto <D.19179>;
    <D.19178>:
    {
      void * * obj;

      D.22547 = block->block;
      D.22533 = block->obj_size;
      D.22548 = D.22533 * i;
      D.22549 = (sizetype) D.22548;
      D.22550 = D.22549 + 16;
      obj = D.22547 + D.22550;
      D.22553 = *obj;
      if (D.22553 != 0B) goto <D.22554>; else goto <D.22555>;
      <D.22554>:
      D.22556 = MEM[(char * *)obj];
      D.22547 = block->block;
      if (D.22556 < D.22547) goto <D.22551>; else goto <D.22557>;
      <D.22557>:
      D.22556 = MEM[(char * *)obj];
      D.22547 = block->block;
      D.22558 = D.22547 + 16384;
      if (D.22556 >= D.22558) goto <D.22551>; else goto <D.22552>;
      <D.22551>:
      D.22533 = block->obj_size;
      D.22559 = (unsigned int) D.22533;
      callback (obj, D.22559, data);
      <D.22552>:
      <D.22555>:
    }
    i = i + 1;
    <D.19179>:
    if (i < count) goto <D.19178>; else goto <D.19180>;
    <D.19180>:
  }
  <D.19176>:
  block = block->next;
  <D.19182>:
  if (block != 0B) goto <D.19181>; else goto <D.19183>;
  <D.19183>:
}


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

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


alloc_obj (struct MonoVTable * vtable, int size, gboolean pinned, gboolean has_references)
{
  int iftmp.242;
  int D.22563;
  int D.22564;
  _Bool D.22568;
  int D.22569;
  int iftmp.243;
  int D.22574;
  unsigned int size_index.244;
  unsigned int D.22576;
  struct MSBlockInfo * * D.22577;
  struct MSBlockInfo * D.22578;
  int D.22581;
  _Bool D.22582;
  long int D.22583;
  long int D.22584;
  void * D.22587;
  int size_index;
  struct MSBlockInfo * * free_blocks;
  void * obj;

  D.22563 = size + 7;
  D.22564 = D.22563 >> 3;
  if (D.22564 <= 31) goto <D.22565>; else goto <D.22566>;
  <D.22565>:
  D.22563 = size + 7;
  D.22564 = D.22563 >> 3;
  iftmp.242 = fast_block_obj_size_indexes[D.22564];
  goto <D.22567>;
  <D.22566>:
  iftmp.242 = ms_find_block_obj_size_index (size);
  <D.22567>:
  size_index = iftmp.242;
  D.22568 = pinned != 0;
  D.22569 = (int) D.22568;
  if (has_references != 0) goto <D.22571>; else goto <D.22572>;
  <D.22571>:
  iftmp.243 = 2;
  goto <D.22573>;
  <D.22572>:
  iftmp.243 = 0;
  <D.22573>:
  D.22574 = D.22569 | iftmp.243;
  free_blocks = free_block_lists[D.22574];
  size_index.244 = (unsigned int) size_index;
  D.22576 = size_index.244 * 4;
  D.22577 = free_blocks + D.22576;
  D.22578 = *D.22577;
  if (D.22578 == 0B) goto <D.22579>; else goto <D.22580>;
  <D.22579>:
  D.22581 = ms_alloc_block (size_index, pinned, has_references);
  D.22582 = D.22581 == 0;
  D.22583 = (long int) D.22582;
  D.22584 = __builtin_expect (D.22583, 0);
  if (D.22584 != 0) goto <D.22585>; else goto <D.22586>;
  <D.22585>:
  D.22587 = 0B;
  return D.22587;
  <D.22586>:
  <D.22580>:
  obj = unlink_slot_from_free_list_uncontested (free_blocks, size_index);
  MEM[(struct MonoVTable * *)obj] = vtable;
  D.22587 = obj;
  return D.22587;
}


ms_alloc_block (int size_index, gboolean pinned, gboolean has_references)
{
  int * block_obj_sizes.245;
  unsigned int size_index.246;
  unsigned int D.22591;
  int * D.22592;
  _Bool D.22593;
  int D.22594;
  int iftmp.247;
  int D.22599;
  int D.22600;
  gboolean D.22603;
  unsigned char D.22606;
  <unnamed-unsigned:1> D.22607;
  unsigned char D.22608;
  <unnamed-unsigned:1> D.22609;
  int D.22610;
  _Bool D.22611;
  void * D.22612;
  char * D.22613;
  sizetype size.248;
  int D.22615;
  struct MSBlockInfo * * D.22616;
  struct MSBlockInfo * D.22617;
  struct MSBlockInfo * all_blocks.249;
  int num_major_sections.250;
  int num_major_sections.251;
  int size;
  int count;
  struct MSBlockInfo * info;
  struct MSBlockHeader * header;
  struct MSBlockInfo * * free_blocks;
  char * obj_start;
  int i;

  block_obj_sizes.245 = block_obj_sizes;
  size_index.246 = (unsigned int) size_index;
  D.22591 = size_index.246 * 4;
  D.22592 = block_obj_sizes.245 + D.22591;
  size = *D.22592;
  count = 16368 / size;
  D.22593 = pinned != 0;
  D.22594 = (int) D.22593;
  if (has_references != 0) goto <D.22596>; else goto <D.22597>;
  <D.22596>:
  iftmp.247 = 2;
  goto <D.22598>;
  <D.22597>:
  iftmp.247 = 0;
  <D.22598>:
  D.22599 = D.22594 | iftmp.247;
  free_blocks = free_block_lists[D.22599];
  D.22600 = sgen_memgov_try_alloc_space (16384, 1);
  if (D.22600 == 0) goto <D.22601>; else goto <D.22602>;
  <D.22601>:
  D.22603 = 0;
  return D.22603;
  <D.22602>:
  info = sgen_alloc_internal (16);
  if (0 != 0) goto <D.22604>; else goto <D.22605>;
  <D.22604>:
  monoeg_g_log (0B, 4, "block with %d objects, it must hold at least 2", count);
  <D.19076>:
  goto <D.19076>;
  <D.22605>:
  info->obj_size = size;
  info->obj_size_index = size_index;
  D.22606 = (unsigned char) pinned;
  D.22607 = (<unnamed-unsigned:1>) D.22606;
  info->pinned = D.22607;
  D.22608 = (unsigned char) has_references;
  D.22609 = (<unnamed-unsigned:1>) D.22608;
  info->has_references = D.22609;
  D.22606 = (unsigned char) pinned;
  D.22607 = (<unnamed-unsigned:1>) D.22606;
  info->has_pinned = D.22607;
  D.22610 = sgen_get_current_collection_generation ();
  D.22611 = D.22610 == 1;
  info->is_to_space = D.22611;
  info->swept = 1;
  D.22612 = ms_get_empty_block ();
  info->block = D.22612;
  header = info->block;
  header->info = info;
  info->cardtable_mod_union = 0B;
  update_heap_boundaries_for_block (info);
  D.22613 = info->block;
  obj_start = D.22613 + 16;
  info->free_list = obj_start;
  i = 0;
  goto <D.19079>;
  <D.19078>:
  {
    char * next_obj_start;

    size.248 = (sizetype) size;
    next_obj_start = obj_start + size.248;
    MEM[(void * *)obj_start] = next_obj_start;
    obj_start = next_obj_start;
  }
  i = i + 1;
  <D.19079>:
  D.22615 = count + -1;
  if (D.22615 > i) goto <D.19078>; else goto <D.19080>;
  <D.19080>:
  MEM[(void * *)obj_start] = 0B;
  size_index.246 = (unsigned int) size_index;
  D.22591 = size_index.246 * 4;
  D.22616 = free_blocks + D.22591;
  D.22617 = *D.22616;
  info->next_free = D.22617;
  size_index.246 = (unsigned int) size_index;
  D.22591 = size_index.246 * 4;
  D.22616 = free_blocks + D.22591;
  *D.22616 = info;
  all_blocks.249 = all_blocks;
  info->next = all_blocks.249;
  all_blocks = info;
  num_major_sections.250 = num_major_sections;
  num_major_sections.251 = num_major_sections.250 + 1;
  num_major_sections = num_major_sections.251;
  D.22603 = 1;
  return D.22603;
}


ms_get_empty_block ()
{
  void * empty_blocks.252;
  const char * iftmp.253;
  int D.22629;
  unsigned int D.22630;
  void * D.22632;
  int D.22633;
  int D.22634;
  long long int D.22635;
  long long int stat_major_blocks_alloced.254;
  long long int stat_major_blocks_alloced.255;
  long long int stat_major_blocks_alloced_less_ideal.256;
  long long int stat_major_blocks_alloced_less_ideal.257;
  void * D.22643;
  int D.22644;
  int D.22645;
  unsigned int block.258;
  unsigned int D.22647;
  _Bool D.22648;
  long int D.22649;
  long int D.22650;
  void * D.22653;
  char * p;
  int i;
  void * block;
  void * empty;
  void * next;
  void retry = <<< error >>>;

  retry:
  empty_blocks.252 = empty_blocks;
  if (empty_blocks.252 == 0B) goto <D.22623>; else goto <D.22624>;
  <D.22623>:
  {
    int alloc_num;

    alloc_num = 32;
    <D.19041>:
    if (alloc_num == 1) goto <D.22626>; else goto <D.22627>;
    <D.22626>:
    iftmp.253 = "major heap section";
    goto <D.22628>;
    <D.22627>:
    iftmp.253 = 0B;
    <D.22628>:
    D.22629 = alloc_num * 16384;
    D.22630 = (unsigned int) D.22629;
    p = sgen_alloc_os_memory_aligned (D.22630, 16384, 3, iftmp.253);
    if (p != 0B) goto <D.19040>; else goto <D.22631>;
    <D.22631>:
    alloc_num = alloc_num >> 1;
    goto <D.19041>;
    <D.19040>:
    i = 0;
    goto <D.19045>;
    <D.19044>:
    block = p;
    <D.19042>:
    empty = empty_blocks;
    MEM[(void * *)block] = empty;
    D.22632 = InterlockedCompareExchangePointer (&empty_blocks, block, empty);
    if (D.22632 != empty) goto <D.19042>; else goto <D.19043>;
    <D.19043>:
    p = p + 16384;
    i = i + 1;
    <D.19045>:
    if (i < alloc_num) goto <D.19044>; else goto <D.19046>;
    <D.19046>:
    {
      int __old_x;

      <D.19048>:
      __old_x = num_empty_blocks;
      D.22633 = __old_x + alloc_num;
      D.22634 = InterlockedCompareExchange (&num_empty_blocks, D.22633, __old_x);
      if (D.22634 != __old_x) goto <D.19048>; else goto <D.19049>;
      <D.19049>:
    }
    D.22635 = (long long int) alloc_num;
    stat_major_blocks_alloced.254 = stat_major_blocks_alloced;
    stat_major_blocks_alloced.255 = D.22635 + stat_major_blocks_alloced.254;
    stat_major_blocks_alloced = stat_major_blocks_alloced.255;
    if (alloc_num != 32) goto <D.22638>; else goto <D.22639>;
    <D.22638>:
    D.22635 = (long long int) alloc_num;
    stat_major_blocks_alloced_less_ideal.256 = stat_major_blocks_alloced_less_ideal;
    stat_major_blocks_alloced_less_ideal.257 = D.22635 + stat_major_blocks_alloced_less_ideal.256;
    stat_major_blocks_alloced_less_ideal = stat_major_blocks_alloced_less_ideal.257;
    <D.22639>:
  }
  <D.22624>:
  <D.19050>:
  empty = empty_blocks;
  if (empty == 0B) goto retry; else goto <D.22642>;
  <D.22642>:
  block = empty;
  next = MEM[(void * *)block];
  D.22643 = InterlockedCompareExchangePointer (&empty_blocks, next, empty);
  if (D.22643 != empty) goto <D.19050>; else goto <D.19051>;
  <D.19051>:
  {
    int __old_x;

    <D.19053>:
    __old_x = num_empty_blocks;
    D.22644 = __old_x + -1;
    D.22645 = InterlockedCompareExchange (&num_empty_blocks, D.22644, __old_x);
    if (D.22645 != __old_x) goto <D.19053>; else goto <D.19054>;
    <D.19054>:
  }
  MEM[(void * *)block] = 0B;
  block.258 = (unsigned int) block;
  D.22647 = block.258 & 16383;
  D.22648 = D.22647 != 0;
  D.22649 = (long int) D.22648;
  D.22650 = __builtin_expect (D.22649, 0);
  if (D.22650 != 0) goto <D.22651>; else goto <D.22652>;
  <D.22651>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 421, "!((mword)block & (MS_BLOCK_SIZE - 1))");
  <D.22652>:
  D.22653 = block;
  return D.22653;
}


unlink_slot_from_free_list_uncontested (struct MSBlockInfo * * free_blocks, int size_index)
{
  unsigned int size_index.259;
  unsigned int D.22656;
  struct MSBlockInfo * * D.22657;
  unsigned char D.22660;
  unsigned char D.22661;
  _Bool D.22662;
  long int D.22663;
  long int D.22664;
  long long int stat_major_blocks_lazy_swept.260;
  long long int stat_major_blocks_lazy_swept.261;
  void * D.22671;
  void * * D.22672;
  struct MSBlockInfo * D.22675;
  void * D.22676;
  struct MSBlockInfo * block;
  void * obj;

  size_index.259 = (unsigned int) size_index;
  D.22656 = size_index.259 * 4;
  D.22657 = free_blocks + D.22656;
  block = *D.22657;
  if (0 != 0) goto <D.22658>; else goto <D.22659>;
  <D.22658>:
  monoeg_g_log (0B, 4, "no free block to unlink from free_blocks %p size_index %d", free_blocks, size_index);
  <D.19094>:
  goto <D.19094>;
  <D.22659>:
  D.22660 = BIT_FIELD_REF <*block, 8, 96>;
  D.22661 = D.22660 & 16;
  D.22662 = D.22661 == 0;
  D.22663 = (long int) D.22662;
  D.22664 = __builtin_expect (D.22663, 0);
  if (D.22664 != 0) goto <D.22665>; else goto <D.22666>;
  <D.22665>:
  stat_major_blocks_lazy_swept.260 = stat_major_blocks_lazy_swept;
  stat_major_blocks_lazy_swept.261 = stat_major_blocks_lazy_swept.260 + 1;
  stat_major_blocks_lazy_swept = stat_major_blocks_lazy_swept.261;
  sweep_block (block, 0);
  <D.22666>:
  obj = block->free_list;
  if (0 != 0) goto <D.22669>; else goto <D.22670>;
  <D.22669>:
  monoeg_g_log (0B, 4, "block %p in free list had no available object to alloc from", block);
  <D.19095>:
  goto <D.19095>;
  <D.22670>:
  D.22671 = MEM[(void * *)obj];
  block->free_list = D.22671;
  D.22672 = block->free_list;
  if (D.22672 == 0B) goto <D.22673>; else goto <D.22674>;
  <D.22673>:
  size_index.259 = (unsigned int) size_index;
  D.22656 = size_index.259 * 4;
  D.22657 = free_blocks + D.22656;
  D.22675 = block->next_free;
  *D.22657 = D.22675;
  block->next_free = 0B;
  <D.22674>:
  D.22676 = obj;
  return D.22676;
}


major_alloc_degraded (struct MonoVTable * vtable, size_t size)
{
  void * D.22678;
  unsigned int D.22679;
  int D.22680;
  int size.262;
  _Bool D.22682;
  long int D.22683;
  long int D.22684;
  int num_major_sections.263;
  _Bool D.22688;
  long int D.22689;
  long int D.22690;
  int D.22693;
  void * D.22694;
  void * obj;
  int old_num_sections;

  old_num_sections = num_major_sections;
  D.22678 = vtable->gc_descr;
  D.22679 = (unsigned int) D.22678;
  D.22680 = sgen_gc_descr_has_references (D.22679);
  size.262 = (int) size;
  obj = alloc_obj (vtable, size.262, 0, D.22680);
  D.22682 = obj != 0B;
  D.22683 = (long int) D.22682;
  D.22684 = __builtin_expect (D.22683, 1);
  if (D.22684 != 0) goto <D.22685>; else goto <D.22686>;
  <D.22685>:
  num_major_sections.263 = num_major_sections;
  D.22688 = num_major_sections.263 < old_num_sections;
  D.22689 = (long int) D.22688;
  D.22690 = __builtin_expect (D.22689, 0);
  if (D.22690 != 0) goto <D.22691>; else goto <D.22692>;
  <D.22691>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-marksweep.c", 842, "num_major_sections >= old_num_sections");
  <D.22692>:
  num_major_sections.263 = num_major_sections;
  D.22693 = num_major_sections.263 - old_num_sections;
  sgen_register_major_sections_alloced (D.22693);
  <D.22686>:
  D.22694 = obj;
  return D.22694;
}


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

  size.264 = (int) size;
  res = alloc_obj (vtable, size.264, 1, has_references);
  if (res == 0B) goto <D.22697>; else goto <D.22698>;
  <D.22697>:
  sgen_perform_collection (0, 1, "pinned alloc failure", 1);
  size.264 = (int) size;
  res = alloc_obj (vtable, size.264, 1, has_references);
  <D.22698>:
  D.22699 = res;
  return D.22699;
}


major_is_object_live (char * obj)
{
  int D.22701;
  gboolean D.22704;
  unsigned int D.22705;
  unsigned int D.22706;
  unsigned int obj.265;
  unsigned int D.22710;
  struct MSBlockHeader * D.22711;
  int obj.266;
  int obj.267;
  int D.22716;
  int D.22717;
  unsigned int D.22721;
  long int D.22722;
  long unsigned int D.22723;
  long unsigned int D.22724;
  _Bool D.22725;
  struct MSBlockInfo * block;
  int word;
  int bit;
  mword objsize;

  D.22701 = sgen_ptr_in_nursery (obj);
  if (D.22701 != 0) goto <D.22702>; else goto <D.22703>;
  <D.22702>:
  D.22704 = 0;
  return D.22704;
  <D.22703>:
  D.22705 = sgen_safe_object_get_size (obj);
  D.22706 = D.22705 + 7;
  objsize = D.22706 & 4294967288;
  if (objsize > 8000) goto <D.22707>; else goto <D.22708>;
  <D.22707>:
  D.22704 = 0;
  return D.22704;
  <D.22708>:
  obj.265 = (unsigned int) obj;
  D.22710 = obj.265 & 4294950912;
  D.22711 = (struct MSBlockHeader *) D.22710;
  block = D.22711->info;
  if (0 != 0) goto <D.22712>; else goto <D.22713>;
  <D.22712>:
  monoeg_g_log (0B, 4, "block %p is pinned, BTW why is this bad?");
  <D.19152>:
  goto <D.19152>;
  <D.22713>:
  {
    int i;

    obj.266 = (int) obj;
    obj.267 = (int) obj;
    D.22716 = obj.267 & -16384;
    D.22717 = obj.266 - D.22716;
    i = D.22717 >> 3;
    if (1 != 0) goto <D.22718>; else goto <D.22719>;
    <D.22718>:
    word = i >> 5;
    bit = i & 31;
    goto <D.22720>;
    <D.22719>:
    word = i >> 6;
    bit = i & 63;
    <D.22720>:
  }
  D.22721 = block->mark_words[word];
  D.22722 = 1 << bit;
  D.22723 = (long unsigned int) D.22722;
  D.22724 = D.22721 & D.22723;
  D.22725 = D.22724 != 0;
  D.22704 = (gboolean) D.22725;
  return D.22704;
}


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

  if (nursery_align != 0) goto <D.22727>; else goto <D.22728>;
  <D.22727>:
  start = sgen_alloc_os_memory_aligned (nursery_size, nursery_align, 3, "nursery");
  goto <D.22729>;
  <D.22728>:
  start = sgen_alloc_os_memory (nursery_size, 3, "nursery");
  <D.22729>:
  D.22730 = start;
  return D.22730;
}


major_get_and_reset_num_major_objects_marked ()
{
  long long int D.22732;

  D.22732 = 0;
  return D.22732;
}


ms_calculate_block_obj_sizes (double factor, int * arr)
{
  double D.22734;
  int D.22735;
  int D.22736;
  unsigned int num_sizes.268;
  unsigned int D.22742;
  int * D.22743;
  int D.22744;
  double target_size;
  int num_sizes;
  int last_size;

  target_size = 8.0e+0;
  num_sizes = 0;
  last_size = 0;
  <D.19771>:
  {
    int target_count;
    int size;

    D.22734 = 1.6368e+4 / target_size;
    target_count = __builtin_lceil (D.22734);
    D.22735 = 16368 / target_count;
    D.22736 = D.22735 & -8;
    size = MIN_EXPR <D.22736, 8000>;
    if (size != last_size) goto <D.22737>; else goto <D.22738>;
    <D.22737>:
    if (arr != 0B) goto <D.22739>; else goto <D.22740>;
    <D.22739>:
    num_sizes.268 = (unsigned int) num_sizes;
    D.22742 = num_sizes.268 * 4;
    D.22743 = arr + D.22742;
    *D.22743 = size;
    <D.22740>:
    num_sizes = num_sizes + 1;
    last_size = size;
    <D.22738>:
    target_size = target_size * factor;
  }
  if (last_size <= 7999) goto <D.19771>; else goto <D.19772>;
  <D.19772>:
  D.22744 = num_sizes;
  return D.22744;
}


alloc_free_block_lists (struct MSBlockInfo * * * lists)
{
  unsigned int i.269;
  unsigned int D.22747;
  struct MSBlockInfo * * * D.22748;
  int num_block_obj_sizes.270;
  unsigned int num_block_obj_sizes.271;
  unsigned int D.22751;
  void * D.22752;
  int i;

  i = 0;
  goto <D.19996>;
  <D.19995>:
  i.269 = (unsigned int) i;
  D.22747 = i.269 * 4;
  D.22748 = lists + D.22747;
  num_block_obj_sizes.270 = num_block_obj_sizes;
  num_block_obj_sizes.271 = (unsigned int) num_block_obj_sizes.270;
  D.22751 = num_block_obj_sizes.271 * 4;
  D.22752 = sgen_alloc_internal_dynamic (D.22751, 15, 1);
  *D.22748 = D.22752;
  i = i + 1;
  <D.19996>:
  if (i <= 3) goto <D.19995>; else goto <D.19997>;
  <D.19997>:
}


ms_find_block_obj_size_index (int size)
{
  int * block_obj_sizes.272;
  unsigned int i.273;
  unsigned int D.22757;
  int * D.22758;
  int D.22759;
  int D.22762;
  int num_block_obj_sizes.274;
  int i;

  if (0 != 0) goto <D.22753>; else goto <D.22754>;
  <D.22753>:
  monoeg_g_log (0B, 4, "size %d is bigger than max small object size %d", size, 8000);
  <D.19016>:
  goto <D.19016>;
  <D.22754>:
  i = 0;
  goto <D.19018>;
  <D.19017>:
  block_obj_sizes.272 = block_obj_sizes;
  i.273 = (unsigned int) i;
  D.22757 = i.273 * 4;
  D.22758 = block_obj_sizes.272 + D.22757;
  D.22759 = *D.22758;
  if (D.22759 >= size) goto <D.22760>; else goto <D.22761>;
  <D.22760>:
  D.22762 = i;
  return D.22762;
  <D.22761>:
  i = i + 1;
  <D.19018>:
  num_block_obj_sizes.274 = num_block_obj_sizes;
  if (i < num_block_obj_sizes.274) goto <D.19017>; else goto <D.19019>;
  <D.19019>:
  monoeg_g_log (0B, 4, "no object of size %d\n", size);
  <D.19020>:
  goto <D.19020>;
}


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