sgen_split_nursery_init (struct SgenMinorCollector * collector)
{
  collector->is_split = 1;
  collector->alloc_for_promotion = minor_alloc_for_promotion;
  collector->par_alloc_for_promotion = minor_par_alloc_for_promotion;
  collector->prepare_to_space = prepare_to_space;
  collector->clear_fragments = clear_fragments;
  collector->build_fragments_get_exclude_head = build_fragments_get_exclude_head;
  collector->build_fragments_release_exclude_head = build_fragments_release_exclude_head;
  collector->build_fragments_finish = build_fragments_finish;
  collector->init_nursery = init_nursery;
  collector->handle_gc_param = handle_gc_param;
  collector->print_gc_param_usage = print_gc_param_usage;
  collector->serial_ops.copy_or_mark_object = split_nursery_serial_copy_object;
  collector->parallel_ops.copy_or_mark_object = split_nursery_parallel_copy_object;
  collector->parallel_ops.scan_object = split_nursery_parallel_scan_object;
  collector->parallel_ops.scan_vtype = split_nursery_parallel_scan_vtype;
  collector->serial_ops.scan_object = split_nursery_serial_scan_object;
  collector->serial_ops.scan_vtype = split_nursery_serial_scan_vtype;
  pthread_mutex_init (&par_alloc_buffer_refill_mutex, 0B);
}


split_nursery_serial_scan_vtype (char * start, mword desc, struct SgenGrayQueue * queue)
{
  unsigned int D.20751;
  unsigned int D.20752;
  unsigned int D.20755;
  unsigned int D.20756;
  unsigned int D.20757;
  unsigned int D.20758;
  unsigned int D.20759;
  void * D.20764;
  struct FILE * gc_debug_file.0;
  unsigned int _index.1;
  unsigned int D.20775;
  int D.20776;
  void * D.20781;
  unsigned int _index.2;
  unsigned int D.20785;
  int D.20786;
  unsigned int D.20793;
  unsigned int D.20796;
  int D.20797;
  int desc.3;
  unsigned int D.20801;
  unsigned int el_size.4;
  unsigned int D.20803;
  void * D.20808;
  int D.20814;
  unsigned int offset.5;
  unsigned int D.20816;
  unsigned int i.6;
  unsigned int D.20818;
  void * * D.20819;
  void * D.20824;
  sizetype el_size.7;
  unsigned int D.20831;
  void * D.20838;
  unsigned int D.20841;
  void * D.20848;
  unsigned int D.20851;
  unsigned int D.20852;
  struct MonoVTable * D.20855;
  struct MonoClass * D.20856;
  const char * D.20857;
  const char * D.20858;
  gsize * bitmap_data.8;
  unsigned int D.20860;
  void * D.20867;
  int bwords.9;

  start = start + 4294967288;
  D.20751 = desc & 7;
  switch (D.20751) <default: <D.20744>, case 1: <D.20670>, case 2: <D.20679>, case 3: <D.20729>, case 4: <D.20689>, case 5: <D.20722>, case 7: <D.20743>>
  <D.20670>:
  D.20752 = desc & 4294901760;
  if (D.20752 != 0) goto <D.20753>; else goto <D.20754>;
  <D.20753>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.20755 = desc >> 16;
    D.20756 = D.20755 & 255;
    D.20757 = D.20756 * 4;
    _objptr = _objptr + D.20757;
    D.20758 = desc >> 24;
    D.20759 = D.20758 * 4;
    _objptr_end = _objptr + D.20759;
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.20760>; else goto <D.20761>;
      <D.20760>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.20762>; else goto <D.20763>;
      <D.20762>:
      D.20764 = *_objptr;
      if (D.20764 != __old) goto <D.20765>; else goto <D.20766>;
      <D.20765>:
      gc_debug_file.0 = gc_debug_file;
      D.20764 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20764, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.20766>:
      <D.20763>:
      <D.20761>:
    }
    _objptr = _objptr + 4;
    goto <D.20676>;
    <D.20675>:
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.20768>; else goto <D.20769>;
      <D.20768>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.20770>; else goto <D.20771>;
      <D.20770>:
      D.20764 = *_objptr;
      if (D.20764 != __old) goto <D.20772>; else goto <D.20773>;
      <D.20772>:
      gc_debug_file.0 = gc_debug_file;
      D.20764 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20764, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.20773>:
      <D.20771>:
      <D.20769>:
    }
    _objptr = _objptr + 4;
    <D.20676>:
    if (_objptr < _objptr_end) goto <D.20675>; else goto <D.20677>;
    <D.20677>:
  }
  <D.20754>:
  goto <D.20678>;
  <D.20679>:
  {
    void * * _objptr;
    gsize _bmap;

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

      _index = __builtin_ctz (_bmap);
      _index.1 = (unsigned int) _index;
      D.20775 = _index.1 * 4;
      _objptr = _objptr + D.20775;
      D.20776 = _index + 1;
      _bmap = _bmap >> D.20776;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.20777>; else goto <D.20778>;
        <D.20777>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.20779>; else goto <D.20780>;
        <D.20779>:
        D.20781 = *_objptr;
        if (D.20781 != __old) goto <D.20782>; else goto <D.20783>;
        <D.20782>:
        gc_debug_file.0 = gc_debug_file;
        D.20781 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20781, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.20783>:
        <D.20780>:
        <D.20778>:
      }
      _objptr = _objptr + 4;
    }
    goto <D.20687>;
    <D.20686>:
    {
      int _index;

      _index = __builtin_ctz (_bmap);
      _index.2 = (unsigned int) _index;
      D.20785 = _index.2 * 4;
      _objptr = _objptr + D.20785;
      D.20786 = _index + 1;
      _bmap = _bmap >> D.20786;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.20787>; else goto <D.20788>;
        <D.20787>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.20789>; else goto <D.20790>;
        <D.20789>:
        D.20781 = *_objptr;
        if (D.20781 != __old) goto <D.20791>; else goto <D.20792>;
        <D.20791>:
        gc_debug_file.0 = gc_debug_file;
        D.20781 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20781, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.20792>:
        <D.20790>:
        <D.20788>:
      }
      _objptr = _objptr + 4;
    }
    <D.20687>:
    if (_bmap != 0) goto <D.20686>; else goto <D.20688>;
    <D.20688>:
  }
  goto <D.20678>;
  <D.20689>:
  D.20793 = desc & 4294950912;
  if (D.20793 != 0) goto <D.20794>; else goto <D.20795>;
  <D.20794>:
  {
    int el_size;
    int etype;

    D.20796 = desc >> 3;
    D.20797 = (int) D.20796;
    el_size = D.20797 & 1023;
    desc.3 = (int) desc;
    etype = desc.3 & 49152;
    if (etype == 16384) goto <D.20799>; else goto <D.20800>;
    <D.20799>:
    {
      void * * p;
      void * * end_refs;

      p = start + 16;
      D.20801 = MEM[(struct MonoArray *)start].max_length;
      el_size.4 = (unsigned int) el_size;
      D.20803 = D.20801 * el_size.4;
      end_refs = p + D.20803;
      goto <D.20696>;
      <D.20695>:
      {
        void * __old;

        __old = *p;
        if (__old != 0B) goto <D.20804>; else goto <D.20805>;
        <D.20804>:
        split_nursery_serial_copy_object_from_obj (p, queue);
        if (0 != 0) goto <D.20806>; else goto <D.20807>;
        <D.20806>:
        D.20808 = *p;
        if (D.20808 != __old) goto <D.20809>; else goto <D.20810>;
        <D.20809>:
        gc_debug_file.0 = gc_debug_file;
        D.20808 = *p;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", p, D.20808, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.20810>:
        <D.20807>:
        <D.20805>:
      }
      p = p + 4;
      <D.20696>:
      if (p < end_refs) goto <D.20695>; else goto <D.20697>;
      <D.20697>:
    }
    goto <D.20811>;
    <D.20800>:
    if (etype == 32768) goto <D.20812>; else goto <D.20813>;
    <D.20812>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.20755 = desc >> 16;
      D.20814 = (int) D.20755;
      offset = D.20814 & 255;
      D.20758 = desc >> 24;
      num_refs = (int) D.20758;
      e_start = start + 16;
      D.20801 = MEM[(struct MonoArray *)start].max_length;
      el_size.4 = (unsigned int) el_size;
      D.20803 = D.20801 * el_size.4;
      e_end = e_start + D.20803;
      goto <D.20709>;
      <D.20708>:
      {
        void * * p;
        int i;

        p = e_start;
        offset.5 = (unsigned int) offset;
        D.20816 = offset.5 * 4;
        p = p + D.20816;
        i = 0;
        goto <D.20706>;
        <D.20705>:
        {
          void * __old;

          i.6 = (unsigned int) i;
          D.20818 = i.6 * 4;
          D.20819 = p + D.20818;
          __old = *D.20819;
          if (__old != 0B) goto <D.20820>; else goto <D.20821>;
          <D.20820>:
          i.6 = (unsigned int) i;
          D.20818 = i.6 * 4;
          D.20819 = p + D.20818;
          split_nursery_serial_copy_object_from_obj (D.20819, queue);
          if (0 != 0) goto <D.20822>; else goto <D.20823>;
          <D.20822>:
          i.6 = (unsigned int) i;
          D.20818 = i.6 * 4;
          D.20819 = p + D.20818;
          D.20824 = *D.20819;
          if (D.20824 != __old) goto <D.20825>; else goto <D.20826>;
          <D.20825>:
          gc_debug_file.0 = gc_debug_file;
          i.6 = (unsigned int) i;
          D.20818 = i.6 * 4;
          D.20819 = p + D.20818;
          i.6 = (unsigned int) i;
          D.20818 = i.6 * 4;
          D.20819 = p + D.20818;
          D.20824 = *D.20819;
          fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", D.20819, D.20824, __old);
          gc_debug_file.0 = gc_debug_file;
          fflush (gc_debug_file.0);
          <D.20826>:
          <D.20823>:
          <D.20821>:
        }
        i = i + 1;
        <D.20706>:
        if (i < num_refs) goto <D.20705>; else goto <D.20707>;
        <D.20707>:
        el_size.7 = (sizetype) el_size;
        e_start = e_start + el_size.7;
      }
      <D.20709>:
      if (e_start < e_end) goto <D.20708>; else goto <D.20710>;
      <D.20710>:
    }
    goto <D.20828>;
    <D.20813>:
    if (etype == 49152) goto <D.20829>; else goto <D.20830>;
    <D.20829>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 16;
      D.20801 = MEM[(struct MonoArray *)start].max_length;
      el_size.4 = (unsigned int) el_size;
      D.20803 = D.20801 * el_size.4;
      e_end = e_start + D.20803;
      goto <D.20720>;
      <D.20719>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.20717>;
        <D.20716>:
        D.20831 = _bmap & 1;
        if (D.20831 != 0) goto <D.20832>; else goto <D.20833>;
        <D.20832>:
        {
          void * __old;

          __old = *p;
          if (__old != 0B) goto <D.20834>; else goto <D.20835>;
          <D.20834>:
          split_nursery_serial_copy_object_from_obj (p, queue);
          if (0 != 0) goto <D.20836>; else goto <D.20837>;
          <D.20836>:
          D.20838 = *p;
          if (D.20838 != __old) goto <D.20839>; else goto <D.20840>;
          <D.20839>:
          gc_debug_file.0 = gc_debug_file;
          D.20838 = *p;
          fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", p, D.20838, __old);
          gc_debug_file.0 = gc_debug_file;
          fflush (gc_debug_file.0);
          <D.20840>:
          <D.20837>:
          <D.20835>:
        }
        <D.20833>:
        _bmap = _bmap >> 1;
        p = p + 4;
        <D.20717>:
        if (_bmap != 0) goto <D.20716>; else goto <D.20718>;
        <D.20718>:
        el_size.7 = (sizetype) el_size;
        e_start = e_start + el_size.7;
      }
      <D.20720>:
      if (e_start < e_end) goto <D.20719>; else goto <D.20721>;
      <D.20721>:
    }
    <D.20830>:
    <D.20828>:
    <D.20811>:
  }
  <D.20795>:
  goto <D.20678>;
  <D.20722>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 3;
    _objptr = _objptr + 8;
    goto <D.20727>;
    <D.20726>:
    D.20841 = _bmap & 1;
    if (D.20841 != 0) goto <D.20842>; else goto <D.20843>;
    <D.20842>:
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.20844>; else goto <D.20845>;
      <D.20844>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.20846>; else goto <D.20847>;
      <D.20846>:
      D.20848 = *_objptr;
      if (D.20848 != __old) goto <D.20849>; else goto <D.20850>;
      <D.20849>:
      gc_debug_file.0 = gc_debug_file;
      D.20848 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20848, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.20850>:
      <D.20847>:
      <D.20845>:
    }
    <D.20843>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 4;
    <D.20727>:
    if (_bmap != 0) goto <D.20726>; else goto <D.20728>;
    <D.20728>:
  }
  goto <D.20678>;
  <D.20729>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.20851 = *bitmap_data;
    D.20852 = D.20851 + 4294967295;
    bwords = (int) D.20852;
    start_run = _objptr;
    bitmap_data = bitmap_data + 4;
    if (0 != 0) goto <D.20853>; else goto <D.20854>;
    <D.20853>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.20855 = myobj->vtable;
      D.20856 = D.20855->klass;
      D.20857 = D.20856->name_space;
      D.20855 = myobj->vtable;
      D.20856 = D.20855->klass;
      D.20858 = D.20856->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.20857, D.20858);
    }
    <D.20854>:
    goto <D.20741>;
    <D.20740>:
    {
      gsize _bmap;

      bitmap_data.8 = bitmap_data;
      bitmap_data = bitmap_data.8 + 4;
      _bmap = *bitmap_data.8;
      _objptr = start_run;
      goto <D.20738>;
      <D.20737>:
      D.20860 = _bmap & 1;
      if (D.20860 != 0) goto <D.20861>; else goto <D.20862>;
      <D.20861>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.20863>; else goto <D.20864>;
        <D.20863>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.20865>; else goto <D.20866>;
        <D.20865>:
        D.20867 = *_objptr;
        if (D.20867 != __old) goto <D.20868>; else goto <D.20869>;
        <D.20868>:
        gc_debug_file.0 = gc_debug_file;
        D.20867 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20867, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.20869>:
        <D.20866>:
        <D.20864>:
      }
      <D.20862>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20738>:
      if (_bmap != 0) goto <D.20737>; else goto <D.20739>;
      <D.20739>:
      start_run = start_run + 128;
    }
    <D.20741>:
    bwords.9 = bwords;
    bwords = bwords.9 + -1;
    if (bwords.9 > 0) goto <D.20740>; else goto <D.20742>;
    <D.20742>:
  }
  goto <D.20678>;
  <D.20743>:
  goto <D.20678>;
  <D.20744>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.20678>:
}


split_nursery_serial_copy_object_from_obj (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.10;
  int D.20875;
  struct FILE * gc_debug_file.11;
  char * iftmp.12;
  unsigned int D.20882;
  unsigned int D.20883;
  unsigned int D.20886;
  int iftmp.13;
  int D.20897;
  int D.20899;
  _Bool D.20901;
  long int D.20902;
  long int D.20903;
  unsigned int D.20906;
  _Bool D.20907;
  long int D.20908;
  long int D.20909;
  int D.20916;
  int D.20919;
  int D.20926;
  int iftmp.14;
  int D.20932;
  int D.20934;
  _Bool D.20936;
  long int D.20937;
  long int D.20938;
  char * forwarded;
  char * obj;
  void * copy;

  obj = *obj_slot;
  if (0 != 0) goto <D.20872>; else goto <D.20873>;
  <D.20872>:
  current_collection_generation.10 = current_collection_generation;
  monoeg_g_log (0B, 4, "calling minor-serial-copy-from-obj from a %d generation collection", current_collection_generation.10);
  <D.20346>:
  goto <D.20346>;
  <D.20873>:
  D.20875 = sgen_ptr_in_nursery (obj);
  if (D.20875 == 0) goto <D.20876>; else goto <D.20877>;
  <D.20876>:
  return;
  <D.20877>:
  if (0 != 0) goto <D.20878>; else goto <D.20879>;
  <D.20878>:
  gc_debug_file.11 = gc_debug_file;
  fprintf (gc_debug_file.11, "Precise copy of %p from %p\n", obj, obj_slot);
  gc_debug_file.11 = gc_debug_file;
  fflush (gc_debug_file.11);
  <D.20879>:
  D.20882 = MEM[(mword *)obj];
  D.20883 = D.20882 & 1;
  if (D.20883 != 0) goto <D.20884>; else goto <D.20885>;
  <D.20884>:
  D.20882 = MEM[(mword *)obj];
  D.20886 = D.20882 & 4294967292;
  iftmp.12 = (char *) D.20886;
  goto <D.20887>;
  <D.20885>:
  iftmp.12 = 0B;
  <D.20887>:
  forwarded = iftmp.12;
  if (forwarded != 0B) goto <D.20888>; else goto <D.20889>;
  <D.20888>:
  if (0 != 0) goto <D.20890>; else goto <D.20891>;
  <D.20890>:
  monoeg_g_log (0B, 4, "forwarded object %p has no gc descriptor", forwarded);
  <D.20347>:
  goto <D.20347>;
  <D.20891>:
  if (0 != 0) goto <D.20892>; else goto <D.20893>;
  <D.20892>:
  gc_debug_file.11 = gc_debug_file;
  fprintf (gc_debug_file.11, " (already forwarded to %p)\n", forwarded);
  gc_debug_file.11 = gc_debug_file;
  fflush (gc_debug_file.11);
  <D.20893>:
  *obj_slot = forwarded;
  D.20897 = sgen_ptr_in_nursery (forwarded);
  if (D.20897 != 0) goto <D.20898>; else goto <D.20895>;
  <D.20898>:
  D.20899 = sgen_ptr_in_nursery (obj_slot);
  if (D.20899 == 0) goto <D.20900>; else goto <D.20895>;
  <D.20900>:
  iftmp.13 = 1;
  goto <D.20896>;
  <D.20895>:
  iftmp.13 = 0;
  <D.20896>:
  D.20901 = iftmp.13 != 0;
  D.20902 = (long int) D.20901;
  D.20903 = __builtin_expect (D.20902, 0);
  if (D.20903 != 0) goto <D.20904>; else goto <D.20905>;
  <D.20904>:
  sgen_add_to_global_remset (obj_slot, forwarded);
  <D.20905>:
  return;
  <D.20889>:
  D.20882 = MEM[(mword *)obj];
  D.20906 = D.20882 & 2;
  D.20907 = D.20906 != 0;
  D.20908 = (long int) D.20907;
  D.20909 = __builtin_expect (D.20908, 0);
  if (D.20909 != 0) goto <D.20910>; else goto <D.20911>;
  <D.20910>:
  if (0 != 0) goto <D.20912>; else goto <D.20913>;
  <D.20912>:
  monoeg_g_log (0B, 4, "pinned object %p has no gc descriptor", obj);
  <D.20348>:
  goto <D.20348>;
  <D.20913>:
  if (0 != 0) goto <D.20914>; else goto <D.20915>;
  <D.20914>:
  gc_debug_file.11 = gc_debug_file;
  fprintf (gc_debug_file.11, " (pinned, no change)\n");
  gc_debug_file.11 = gc_debug_file;
  fflush (gc_debug_file.11);
  <D.20915>:
  D.20916 = sgen_ptr_in_nursery (obj_slot);
  if (D.20916 == 0) goto <D.20917>; else goto <D.20918>;
  <D.20917>:
  sgen_add_to_global_remset (obj_slot, obj);
  <D.20918>:
  return;
  <D.20911>:
  D.20919 = sgen_nursery_is_to_space (obj);
  if (D.20919 != 0) goto <D.20920>; else goto <D.20921>;
  <D.20920>:
  if (0 != 0) goto <D.20922>; else goto <D.20923>;
  <D.20922>:
  monoeg_g_log (0B, 4, "to space object %p has no gc descriptor", obj);
  <D.20349>:
  goto <D.20349>;
  <D.20923>:
  if (0 != 0) goto <D.20924>; else goto <D.20925>;
  <D.20924>:
  gc_debug_file.11 = gc_debug_file;
  fprintf (gc_debug_file.11, " (tospace, no change)\n");
  gc_debug_file.11 = gc_debug_file;
  fflush (gc_debug_file.11);
  <D.20925>:
  D.20926 = sgen_ptr_in_nursery (obj_slot);
  if (D.20926 == 0) goto <D.20927>; else goto <D.20928>;
  <D.20927>:
  sgen_add_to_global_remset (obj_slot, obj);
  <D.20928>:
  return;
  <D.20921>:
  copy = copy_object_no_checks (obj, queue);
  *obj_slot = copy;
  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 (obj_slot);
  if (D.20934 == 0) goto <D.20935>; else goto <D.20930>;
  <D.20935>:
  iftmp.14 = 1;
  goto <D.20931>;
  <D.20930>:
  iftmp.14 = 0;
  <D.20931>:
  D.20936 = iftmp.14 != 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 (obj_slot, copy);
  <D.20940>:
}


sgen_nursery_is_to_space (char * object)
{
  int object.15;
  char * sgen_nursery_start.16;
  int sgen_nursery_start.17;
  int D.20945;
  int D.20946;
  _Bool D.20947;
  long int D.20948;
  long int D.20949;
  char * D.20952;
  char * D.20953;
  int sgen_space_bitmap_size.18;
  _Bool D.20955;
  long int D.20956;
  long int D.20957;
  gboolean D.20960;
  char * sgen_space_bitmap.19;
  sizetype byte.20;
  char * D.20963;
  char D.20964;
  int D.20965;
  int D.20966;
  int D.20967;
  _Bool D.20968;
  int idx;
  int byte;
  int bit;

  object.15 = (int) object;
  sgen_nursery_start.16 = sgen_nursery_start;
  sgen_nursery_start.17 = (int) sgen_nursery_start.16;
  D.20945 = object.15 - sgen_nursery_start.17;
  idx = D.20945 >> 9;
  byte = idx / 8;
  bit = idx & 7;
  D.20946 = sgen_ptr_in_nursery (object);
  D.20947 = D.20946 == 0;
  D.20948 = (long int) D.20947;
  D.20949 = __builtin_expect (D.20948, 0);
  if (D.20949 != 0) goto <D.20950>; else goto <D.20951>;
  <D.20950>:
  D.20952 = sgen_get_nursery_start ();
  D.20953 = sgen_get_nursery_end ();
  monoeg_g_log (0B, 4, "object %p is not in nursery [%p - %p]", object, D.20952, D.20953);
  <D.19631>:
  goto <D.19631>;
  <D.20951>:
  sgen_space_bitmap_size.18 = sgen_space_bitmap_size;
  D.20955 = byte >= sgen_space_bitmap_size.18;
  D.20956 = (long int) D.20955;
  D.20957 = __builtin_expect (D.20956, 0);
  if (D.20957 != 0) goto <D.20958>; else goto <D.20959>;
  <D.20958>:
  sgen_space_bitmap_size.18 = sgen_space_bitmap_size;
  monoeg_g_log (0B, 4, "byte index %d out of range", byte, sgen_space_bitmap_size.18);
  <D.19632>:
  goto <D.19632>;
  <D.20959>:
  sgen_space_bitmap.19 = sgen_space_bitmap;
  byte.20 = (sizetype) byte;
  D.20963 = sgen_space_bitmap.19 + byte.20;
  D.20964 = *D.20963;
  D.20965 = (int) D.20964;
  D.20966 = D.20965 >> bit;
  D.20967 = D.20966 & 1;
  D.20968 = D.20967 != 0;
  D.20960 = (gboolean) D.20968;
  return D.20960;
}


sgen_get_nursery_start ()
{
  char * D.20970;

  D.20970 = sgen_nursery_start;
  return D.20970;
}


sgen_get_nursery_end ()
{
  char * D.20972;

  D.20972 = sgen_nursery_end;
  return D.20972;
}


copy_object_no_checks (void * obj, struct SgenGrayQueue * queue)
{
  void * D.20974;
  unsigned int D.20975;
  unsigned int D.20976;
  unsigned int D.20977;
  _Bool D.20978;
  long int D.20979;
  long int D.20980;
  void * D.20983;
  struct SgenGrayQueue * iftmp.21;
  unsigned int destination.22;
  unsigned int D.20989;
  struct MonoVTable * vt;
  gboolean has_references;
  mword objsize;
  char * destination;

  vt = MEM[(struct MonoObject *)obj].vtable;
  D.20974 = vt->gc_descr;
  D.20975 = (unsigned int) D.20974;
  has_references = sgen_gc_descr_has_references (D.20975);
  D.20976 = sgen_par_object_get_size (vt, obj);
  D.20977 = D.20976 + 7;
  objsize = D.20977 & 4294967288;
  destination = alloc_for_promotion (vt, obj, objsize, has_references);
  D.20978 = destination == 0B;
  D.20979 = (long int) D.20978;
  D.20980 = __builtin_expect (D.20979, 0);
  if (D.20980 != 0) goto <D.20981>; else goto <D.20982>;
  <D.20981>:
  sgen_pin_object (obj, queue);
  sgen_set_pinned_from_failed_allocation (objsize);
  D.20983 = obj;
  return D.20983;
  <D.20982>:
  if (has_references != 0) goto <D.20985>; else goto <D.20986>;
  <D.20985>:
  iftmp.21 = queue;
  goto <D.20987>;
  <D.20986>:
  iftmp.21 = 0B;
  <D.20987>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.21);
  destination.22 = (unsigned int) destination;
  D.20989 = destination.22 | 1;
  MEM[(mword *)obj] = D.20989;
  D.20983 = destination;
  return D.20983;
}


sgen_gc_descr_has_references (mword desc)
{
  unsigned int D.20991;
  gboolean D.20994;
  unsigned int D.20995;
  unsigned int D.20998;

  D.20991 = desc & 4294901767;
  if (D.20991 == 1) goto <D.20992>; else goto <D.20993>;
  <D.20992>:
  D.20994 = 0;
  return D.20994;
  <D.20993>:
  D.20995 = desc & 49159;
  if (D.20995 == 4) goto <D.20996>; else goto <D.20997>;
  <D.20996>:
  D.20994 = 0;
  return D.20994;
  <D.20997>:
  D.20998 = desc & 7;
  if (D.20998 == 7) goto <D.20999>; else goto <D.21000>;
  <D.20999>:
  D.20994 = 0;
  return D.20994;
  <D.21000>:
  D.20994 = 1;
  return D.20994;
}


sgen_par_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  void * D.21002;
  unsigned int D.21003;
  guint D.21008;
  int D.21009;
  int D.21010;
  unsigned int D.21011;
  unsigned int D.21014;
  int D.21015;
  unsigned int D.21016;
  unsigned int element_size.23;
  unsigned int D.21018;
  unsigned int D.21019;
  struct MonoClass * D.21022;
  unsigned char D.21023;
  unsigned int D.21024;
  unsigned int D.21025;
  mword descr;
  mword type;

  D.21002 = vtable->gc_descr;
  descr = (mword) D.21002;
  type = descr & 7;
  D.21003 = type + 4294967295;
  if (D.21003 <= 1) goto <D.21004>; else goto <D.21005>;
  <D.21004>:
  {
    mword size;

    size = descr & 65528;
    if (size == 0) goto <D.21006>; else goto <D.21007>;
    <D.21006>:
    D.21009 = MEM[(struct MonoString *)o].length;
    D.21010 = D.21009 * 2;
    D.21011 = (unsigned int) D.21010;
    D.21008 = D.21011 + 14;
    return D.21008;
    <D.21007>:
    D.21008 = size;
    return D.21008;
  }
  <D.21005>:
  if (type == 4) goto <D.21012>; else goto <D.21013>;
  <D.21012>:
  {
    int element_size;
    struct MonoArray * array;
    size_t size;

    D.21014 = descr >> 3;
    D.21015 = (int) D.21014;
    element_size = D.21015 & 1023;
    array = o;
    D.21016 = array->max_length;
    element_size.23 = (unsigned int) element_size;
    D.21018 = D.21016 * element_size.23;
    size = D.21018 + 16;
    D.21019 = descr & 8192;
    if (D.21019 != 0) goto <D.21020>; else goto <D.21021>;
    <D.21020>:
    size = size + 3;
    size = size & 4294967292;
    D.21022 = vtable->klass;
    D.21023 = D.21022->rank;
    D.21024 = (unsigned int) D.21023;
    D.21025 = D.21024 * 8;
    size = D.21025 + size;
    <D.21021>:
    D.21008 = size;
    return D.21008;
  }
  <D.21013>:
  D.21008 = slow_object_get_size (vtable, o);
  return D.21008;
}


slow_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  struct MonoClass * D.21027;
  guint D.21030;
  int D.21031;
  int D.21032;
  unsigned int D.21033;
  unsigned char D.21034;
  int D.21037;
  unsigned int D.21038;
  unsigned int D.21039;
  unsigned int D.21040;
  struct MonoArrayBounds * D.21041;
  _Bool D.21042;
  long int D.21043;
  long int D.21044;
  unsigned int D.21047;
  unsigned int D.21048;
  int D.21049;
  struct MonoClass * klass;

  klass = vtable->klass;
  D.21027 = mono_defaults.string_class;
  if (D.21027 == klass) goto <D.21028>; else goto <D.21029>;
  <D.21028>:
  D.21031 = MEM[(struct MonoString *)o].length;
  D.21032 = D.21031 * 2;
  D.21033 = (unsigned int) D.21032;
  D.21030 = D.21033 + 14;
  return D.21030;
  <D.21029>:
  D.21034 = klass->rank;
  if (D.21034 != 0) goto <D.21035>; else goto <D.21036>;
  <D.21035>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.21037 = klass->sizes.element_size;
    D.21038 = (unsigned int) D.21037;
    D.21039 = array->max_length;
    D.21040 = D.21038 * D.21039;
    size = D.21040 + 16;
    D.21041 = array->bounds;
    D.21042 = D.21041 != 0B;
    D.21043 = (long int) D.21042;
    D.21044 = __builtin_expect (D.21043, 0);
    if (D.21044 != 0) goto <D.21045>; else goto <D.21046>;
    <D.21045>:
    size = size + 3;
    size = size & 4294967292;
    D.21034 = klass->rank;
    D.21047 = (unsigned int) D.21034;
    D.21048 = D.21047 * 8;
    size = D.21048 + size;
    <D.21046>:
    D.21030 = size;
    return D.21030;
  }
  <D.21036>:
  D.21049 = klass->instance_size;
  D.21030 = (guint) D.21049;
  return D.21030;
}


alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int promote_age.24;
  char * D.21054;
  void * (*<T3846>) (struct MonoVTable *, int, gboolean) D.21055;
  int objsize.25;
  char * D.21057;
  char * D.21058;
  _Bool D.21059;
  long int D.21060;
  long int D.21061;
  char * D.21064;
  char * D.21065;
  char * p;
  int age;

  p = 0B;
  age = get_object_age (obj);
  promote_age.24 = promote_age;
  if (age >= promote_age.24) goto <D.21052>; else goto <D.21053>;
  <D.21052>:
  D.21055 = major_collector.alloc_object;
  objsize.25 = (int) objsize;
  D.21054 = D.21055 (vtable, objsize.25, has_references);
  return D.21054;
  <D.21053>:
  age = age + 1;
  p = age_alloc_buffers[age].next;
  D.21057 = p + objsize;
  D.21058 = age_alloc_buffers[age].end;
  D.21059 = D.21057 <= D.21058;
  D.21060 = (long int) D.21059;
  D.21061 = __builtin_expect (D.21060, 1);
  if (D.21061 != 0) goto <D.21062>; else goto <D.21063>;
  <D.21062>:
  D.21064 = age_alloc_buffers[age].next;
  D.21065 = D.21064 + objsize;
  age_alloc_buffers[age].next = D.21065;
  goto <D.21066>;
  <D.21063>:
  p = alloc_for_promotion_slow_path (age, objsize);
  if (p == 0B) goto <D.21067>; else goto <D.21068>;
  <D.21067>:
  D.21055 = major_collector.alloc_object;
  objsize.25 = (int) objsize;
  D.21054 = D.21055 (vtable, objsize.25, has_references);
  return D.21054;
  <D.21068>:
  <D.21066>:
  MEM[(struct MonoVTable * *)p] = vtable;
  D.21054 = p;
  return D.21054;
}


get_object_age (char * object)
{
  int object.26;
  char * sgen_nursery_start.27;
  int sgen_nursery_start.28;
  int D.21073;
  int D.21074;
  char * region_age.29;
  sizetype idx.30;
  char * D.21077;
  char D.21078;
  int idx;

  object.26 = (int) object;
  sgen_nursery_start.27 = sgen_nursery_start;
  sgen_nursery_start.28 = (int) sgen_nursery_start.27;
  D.21073 = object.26 - sgen_nursery_start.28;
  idx = D.21073 >> 9;
  region_age.29 = region_age;
  idx.30 = (sizetype) idx;
  D.21077 = region_age.29 + idx.30;
  D.21078 = *D.21077;
  D.21074 = (int) D.21078;
  return D.21074;
}


alloc_for_promotion_slow_path (int age, size_t objsize)
{
  unsigned int D.21080;
  unsigned int D.21081;
  unsigned int D.21082;
  unsigned int allocated_size.31;
  char * D.21086;
  char * D.21087;
  char * D.21088;
  char * D.21089;
  char * D.21090;
  char * p;
  size_t allocated_size;
  size_t aligned_objsize;

  try
    {
      D.21080 = objsize + 511;
      aligned_objsize = D.21080 & 4294966784;
      D.21081 = MAX_EXPR <aligned_objsize, 4096>;
      D.21082 = MAX_EXPR <aligned_objsize, 512>;
      p = sgen_fragment_allocator_serial_range_alloc (&collector_allocator, D.21081, D.21082, &allocated_size);
      if (p != 0B) goto <D.21083>; else goto <D.21084>;
      <D.21083>:
      allocated_size.31 = allocated_size;
      D.21086 = p + allocated_size.31;
      set_age_in_range (p, D.21086, age);
      D.21087 = age_alloc_buffers[age].next;
      D.21088 = age_alloc_buffers[age].end;
      sgen_clear_range (D.21087, D.21088);
      D.21089 = p + objsize;
      age_alloc_buffers[age].next = D.21089;
      allocated_size.31 = allocated_size;
      D.21086 = p + allocated_size.31;
      age_alloc_buffers[age].end = D.21086;
      <D.21084>:
      D.21090 = p;
      return D.21090;
    }
  finally
    {
      allocated_size = {CLOBBER};
    }
}


set_age_in_range (char * start, char * end, int age)
{
  int start.32;
  char * sgen_nursery_start.33;
  int sgen_nursery_start.34;
  int D.21096;
  char * region_age.35;
  sizetype region_idx.36;
  int end.37;
  int D.21100;
  unsigned int length.38;
  char * region_start;
  int region_idx;
  int length;

  start.32 = (int) start;
  sgen_nursery_start.33 = sgen_nursery_start;
  sgen_nursery_start.34 = (int) sgen_nursery_start.33;
  D.21096 = start.32 - sgen_nursery_start.34;
  region_idx = D.21096 >> 9;
  region_age.35 = region_age;
  region_idx.36 = (sizetype) region_idx;
  region_start = region_age.35 + region_idx.36;
  end.37 = (int) end;
  start.32 = (int) start;
  D.21100 = end.37 - start.32;
  length = D.21100 >> 9;
  length.38 = (unsigned int) length;
  memset (region_start, age, length.38);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.21104;
  int D.21109;
  void * D.21111;
  unsigned int D.21112;

  D.21104 = __builtin_constant_p (__len);
  if (D.21104 != 0) goto <D.21105>; else goto <D.21106>;
  <D.21105>:
  if (__len == 0) goto <D.21107>; else goto <D.21108>;
  <D.21107>:
  D.21109 = __builtin_constant_p (__ch);
  if (D.21109 == 0) goto <D.21102>; else goto <D.21110>;
  <D.21110>:
  if (__ch != 0) goto <D.21102>; else goto <D.21103>;
  <D.21102>:
  __warn_memset_zero_len ();
  D.21111 = __dest;
  return D.21111;
  <D.21103>:
  <D.21108>:
  <D.21106>:
  D.21112 = __builtin_object_size (__dest, 0);
  D.21111 = __builtin___memset_chk (__dest, __ch, __len, D.21112);
  return D.21111;
}


par_copy_object_no_checks (char * destination, struct MonoVTable * vt, void * obj, mword objsize, struct SgenGrayQueue * queue)
{
  struct MonoClass * D.21116;
  const char * D.21117;
  const char * D.21118;
  struct FILE * gc_debug_file.39;
  struct MonoVTable * D.21122;
  struct MonoClass * D.21123;
  const char * D.21124;
  unsigned int D.21127;
  const void * D.21128;
  mword * D.21129;
  unsigned int D.21130;
  mword * D.21131;
  unsigned int D.21132;
  mword * D.21133;
  unsigned int D.21134;
  mword * D.21135;
  unsigned int D.21136;
  mword * D.21137;
  unsigned int D.21138;
  mword * D.21139;
  unsigned int D.21140;
  mword * D.21141;
  unsigned int D.21142;
  void * D.21144;
  const void * D.21145;
  unsigned int D.21146;
  int iftmp.40;
  unsigned char D.21152;
  struct MonoArrayBounds * D.21154;
  _Bool D.21156;
  long int D.21157;
  long int D.21158;
  int D.21161;
  int obj.41;
  int D.21163;
  sizetype D.21164;
  struct MonoArrayBounds * D.21165;
  int D.21168;
  unsigned int D.21169;
  <unnamed type> mono_profiler_events.42;
  unsigned int D.21171;
  _Bool D.21172;
  long int D.21173;
  long int D.21174;
  const char * D.21181;
  int iftmp.43;
  struct GrayQueueSection * D.21186;
  int D.21188;
  _Bool D.21189;
  long int D.21190;
  long int D.21191;
  int D.21195;
  int D.21196;
  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.21114>; else goto <D.21115>;
  <D.21114>:
  D.21116 = vt->klass;
  D.21117 = D.21116->name_space;
  D.21116 = vt->klass;
  D.21118 = D.21116->name;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s was not initialized", vt, D.21117, D.21118);
  <D.20317>:
  goto <D.20317>;
  <D.21115>:
  if (0 != 0) goto <D.21119>; else goto <D.21120>;
  <D.21119>:
  gc_debug_file.39 = gc_debug_file;
  D.21122 = MEM[(struct MonoObject *)obj].vtable;
  D.21123 = D.21122->klass;
  D.21124 = D.21123->name;
  fprintf (gc_debug_file.39, " (to %p, %s size: %lu)\n", destination, D.21124, objsize);
  gc_debug_file.39 = gc_debug_file;
  fflush (gc_debug_file.39);
  <D.21120>:
  if (objsize <= 32) goto <D.21125>; else goto <D.21126>;
  <D.21125>:
  {
    mword * dest;

    dest = destination;
    D.21127 = objsize / 4;
    D.21128 = copy_labels[D.21127];
    goto D.21128;
    LAB_8:
    D.21129 = dest + 28;
    D.21130 = MEM[(mword *)obj + 28B];
    *D.21129 = D.21130;
    LAB_7:
    D.21131 = dest + 24;
    D.21132 = MEM[(mword *)obj + 24B];
    *D.21131 = D.21132;
    LAB_6:
    D.21133 = dest + 20;
    D.21134 = MEM[(mword *)obj + 20B];
    *D.21133 = D.21134;
    LAB_5:
    D.21135 = dest + 16;
    D.21136 = MEM[(mword *)obj + 16B];
    *D.21135 = D.21136;
    LAB_4:
    D.21137 = dest + 12;
    D.21138 = MEM[(mword *)obj + 12B];
    *D.21137 = D.21138;
    LAB_3:
    D.21139 = dest + 8;
    D.21140 = MEM[(mword *)obj + 8B];
    *D.21139 = D.21140;
    LAB_2:
    D.21141 = dest + 4;
    D.21142 = MEM[(mword *)obj + 4B];
    *D.21141 = D.21142;
    LAB_1:
    LAB_0:
  }
  goto <D.21143>;
  <D.21126>:
  D.21144 = destination + 4;
  D.21145 = obj + 4;
  D.21146 = objsize + 4294967292;
  mono_gc_memmove_aligned (D.21144, D.21145, D.21146);
  <D.21143>:
  if (0 != 0) goto <D.21147>; else goto <D.21148>;
  <D.21147>:
  D.21116 = vt->klass;
  D.21117 = D.21116->name_space;
  D.21116 = vt->klass;
  D.21118 = D.21116->name;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s has no gc descriptor", vt, D.21117, D.21118);
  <D.20319>:
  goto <D.20319>;
  <D.21148>:
  D.21152 = vt->rank;
  if (D.21152 != 0) goto <D.21153>; else goto <D.21150>;
  <D.21153>:
  D.21154 = MEM[(struct MonoArray *)obj].bounds;
  if (D.21154 != 0B) goto <D.21155>; else goto <D.21150>;
  <D.21155>:
  iftmp.40 = 1;
  goto <D.21151>;
  <D.21150>:
  iftmp.40 = 0;
  <D.21151>:
  D.21156 = iftmp.40 != 0;
  D.21157 = (long int) D.21156;
  D.21158 = __builtin_expect (D.21157, 0);
  if (D.21158 != 0) goto <D.21159>; else goto <D.21160>;
  <D.21159>:
  {
    struct MonoArray * array;

    array = destination;
    D.21154 = MEM[(struct MonoArray *)obj].bounds;
    D.21161 = (int) D.21154;
    obj.41 = (int) obj;
    D.21163 = D.21161 - obj.41;
    D.21164 = (sizetype) D.21163;
    D.21165 = destination + D.21164;
    array->bounds = D.21165;
    if (0 != 0) goto <D.21166>; else goto <D.21167>;
    <D.21166>:
    gc_debug_file.39 = gc_debug_file;
    D.21152 = vt->rank;
    D.21168 = (int) D.21152;
    D.21169 = mono_array_length (array);
    fprintf (gc_debug_file.39, "Array instance %p: size: %lu, rank: %d, length: %lu\n", array, objsize, D.21168, D.21169);
    gc_debug_file.39 = gc_debug_file;
    fflush (gc_debug_file.39);
    <D.21167>:
  }
  <D.21160>:
  mono_profiler_events.42 = mono_profiler_events;
  D.21171 = mono_profiler_events.42 & 524288;
  D.21172 = D.21171 != 0;
  D.21173 = (long int) D.21172;
  D.21174 = __builtin_expect (D.21173, 0);
  if (D.21174 != 0) goto <D.21175>; else goto <D.21176>;
  <D.21175>:
  sgen_register_moved_object (obj, destination);
  <D.21176>:
  obj = destination;
  if (queue != 0B) goto <D.21177>; else goto <D.21178>;
  <D.21177>:
  if (0 != 0) goto <D.21179>; else goto <D.21180>;
  <D.21179>:
  gc_debug_file.39 = gc_debug_file;
  D.21181 = sgen_safe_name (obj);
  fprintf (gc_debug_file.39, "Enqueuing gray object %p (%s)\n", obj, D.21181);
  gc_debug_file.39 = gc_debug_file;
  fflush (gc_debug_file.39);
  <D.21180>:
  D.21186 = queue->first;
  if (D.21186 == 0B) goto <D.21183>; else goto <D.21187>;
  <D.21187>:
  D.21186 = queue->first;
  D.21188 = D.21186->end;
  if (D.21188 == 125) goto <D.21183>; else goto <D.21184>;
  <D.21183>:
  iftmp.43 = 1;
  goto <D.21185>;
  <D.21184>:
  iftmp.43 = 0;
  <D.21185>:
  D.21189 = iftmp.43 != 0;
  D.21190 = (long int) D.21189;
  D.21191 = __builtin_expect (D.21190, 0);
  if (D.21191 != 0) goto <D.21192>; else goto <D.21193>;
  <D.21192>:
  sgen_gray_object_enqueue (queue, obj);
  goto <D.21194>;
  <D.21193>:
  D.21186 = queue->first;
  D.21186 = queue->first;
  D.21188 = D.21186->end;
  D.21195 = D.21188;
  D.21196 = D.21195 + 1;
  D.21186->end = D.21196;
  D.21186->objects[D.21195] = obj;
  <D.21194>:
  __builtin_prefetch (obj);
  <D.21178>:
}


sgen_ptr_in_nursery (void * p)
{
  gboolean D.21199;
  int sgen_nursery_bits.45;
  int D.21201;
  int D.21202;
  unsigned int D.21203;
  unsigned int p.46;
  unsigned int D.21205;
  char * sgen_nursery_start.47;
  unsigned int sgen_nursery_start.48;
  _Bool D.21208;

  sgen_nursery_bits.45 = sgen_nursery_bits;
  D.21201 = 1 << sgen_nursery_bits.45;
  D.21202 = -D.21201;
  D.21203 = (unsigned int) D.21202;
  p.46 = (unsigned int) p;
  D.21205 = D.21203 & p.46;
  sgen_nursery_start.47 = sgen_nursery_start;
  sgen_nursery_start.48 = (unsigned int) sgen_nursery_start.47;
  D.21208 = D.21205 == sgen_nursery_start.48;
  D.21199 = (gboolean) D.21208;
  return D.21199;
}


split_nursery_serial_scan_object (char * start, struct SgenGrayQueue * queue)
{
  unsigned int D.21210;
  unsigned int D.21211;
  unsigned int D.21212;
  unsigned int D.21213;
  unsigned int D.21216;
  unsigned int D.21217;
  unsigned int D.21218;
  unsigned int D.21219;
  unsigned int D.21220;
  void * D.21225;
  struct FILE * gc_debug_file.49;
  unsigned int _index.50;
  unsigned int D.21236;
  int D.21237;
  void * D.21242;
  unsigned int _index.51;
  unsigned int D.21246;
  int D.21247;
  unsigned int D.21254;
  unsigned int D.21257;
  int D.21258;
  int desc.52;
  unsigned int D.21262;
  unsigned int el_size.53;
  unsigned int D.21264;
  void * D.21269;
  int D.21275;
  unsigned int offset.54;
  unsigned int D.21277;
  unsigned int i.55;
  unsigned int D.21279;
  void * * D.21280;
  void * D.21285;
  sizetype el_size.56;
  unsigned int D.21292;
  void * D.21299;
  unsigned int D.21302;
  void * D.21309;
  unsigned int D.21312;
  unsigned int D.21313;
  struct MonoVTable * D.21316;
  struct MonoClass * D.21317;
  const char * D.21318;
  const char * D.21319;
  gsize * bitmap_data.57;
  unsigned int D.21321;
  void * D.21328;
  int bwords.58;
  unsigned int D.21332;
  gsize * mbitmap_data.59;
  unsigned int D.21334;
  unsigned int D.21335;
  struct MonoClass * D.21336;
  unsigned int el_size.60;
  unsigned int D.21338;
  const char * D.21341;
  const char * D.21342;
  gsize * bitmap_data.61;
  unsigned int D.21344;
  void * D.21351;
  unsigned int bwords.62;
  sizetype el_size.63;

  {
    struct GCVTable * vt;
    mword desc;

    D.21210 = MEM[(mword *)start];
    D.21211 = D.21210 & 4294967292;
    vt = (struct GCVTable *) D.21211;
    desc = vt->desc;
    D.21212 = desc & 7;
    switch (D.21212) <default: <D.20664>, case 1: <D.20569>, case 2: <D.20578>, case 3: <D.20628>, case 4: <D.20588>, case 5: <D.20621>, case 6: <D.20642>, case 7: <D.20663>>
    <D.20569>:
    D.21213 = desc & 4294901760;
    if (D.21213 != 0) goto <D.21214>; else goto <D.21215>;
    <D.21214>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.21216 = desc >> 16;
      D.21217 = D.21216 & 255;
      D.21218 = D.21217 * 4;
      _objptr = _objptr + D.21218;
      D.21219 = desc >> 24;
      D.21220 = D.21219 * 4;
      _objptr_end = _objptr + D.21220;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.21221>; else goto <D.21222>;
        <D.21221>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.21223>; else goto <D.21224>;
        <D.21223>:
        D.21225 = *_objptr;
        if (D.21225 != __old) goto <D.21226>; else goto <D.21227>;
        <D.21226>:
        gc_debug_file.49 = gc_debug_file;
        D.21225 = *_objptr;
        fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21225, __old);
        gc_debug_file.49 = gc_debug_file;
        fflush (gc_debug_file.49);
        <D.21227>:
        <D.21224>:
        <D.21222>:
      }
      _objptr = _objptr + 4;
      goto <D.20575>;
      <D.20574>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.21229>; else goto <D.21230>;
        <D.21229>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.21231>; else goto <D.21232>;
        <D.21231>:
        D.21225 = *_objptr;
        if (D.21225 != __old) goto <D.21233>; else goto <D.21234>;
        <D.21233>:
        gc_debug_file.49 = gc_debug_file;
        D.21225 = *_objptr;
        fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21225, __old);
        gc_debug_file.49 = gc_debug_file;
        fflush (gc_debug_file.49);
        <D.21234>:
        <D.21232>:
        <D.21230>:
      }
      _objptr = _objptr + 4;
      <D.20575>:
      if (_objptr < _objptr_end) goto <D.20574>; else goto <D.20576>;
      <D.20576>:
    }
    <D.21215>:
    goto <D.20577>;
    <D.20578>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.50 = (unsigned int) _index;
        D.21236 = _index.50 * 4;
        _objptr = _objptr + D.21236;
        D.21237 = _index + 1;
        _bmap = _bmap >> D.21237;
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.21238>; else goto <D.21239>;
          <D.21238>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.21240>; else goto <D.21241>;
          <D.21240>:
          D.21242 = *_objptr;
          if (D.21242 != __old) goto <D.21243>; else goto <D.21244>;
          <D.21243>:
          gc_debug_file.49 = gc_debug_file;
          D.21242 = *_objptr;
          fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21242, __old);
          gc_debug_file.49 = gc_debug_file;
          fflush (gc_debug_file.49);
          <D.21244>:
          <D.21241>:
          <D.21239>:
        }
        _objptr = _objptr + 4;
      }
      goto <D.20586>;
      <D.20585>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.51 = (unsigned int) _index;
        D.21246 = _index.51 * 4;
        _objptr = _objptr + D.21246;
        D.21247 = _index + 1;
        _bmap = _bmap >> D.21247;
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.21248>; else goto <D.21249>;
          <D.21248>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.21250>; else goto <D.21251>;
          <D.21250>:
          D.21242 = *_objptr;
          if (D.21242 != __old) goto <D.21252>; else goto <D.21253>;
          <D.21252>:
          gc_debug_file.49 = gc_debug_file;
          D.21242 = *_objptr;
          fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21242, __old);
          gc_debug_file.49 = gc_debug_file;
          fflush (gc_debug_file.49);
          <D.21253>:
          <D.21251>:
          <D.21249>:
        }
        _objptr = _objptr + 4;
      }
      <D.20586>:
      if (_bmap != 0) goto <D.20585>; else goto <D.20587>;
      <D.20587>:
    }
    goto <D.20577>;
    <D.20588>:
    D.21254 = desc & 4294950912;
    if (D.21254 != 0) goto <D.21255>; else goto <D.21256>;
    <D.21255>:
    {
      int el_size;
      int etype;

      D.21257 = desc >> 3;
      D.21258 = (int) D.21257;
      el_size = D.21258 & 1023;
      desc.52 = (int) desc;
      etype = desc.52 & 49152;
      if (etype == 16384) goto <D.21260>; else goto <D.21261>;
      <D.21260>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.21262 = MEM[(struct MonoArray *)start].max_length;
        el_size.53 = (unsigned int) el_size;
        D.21264 = D.21262 * el_size.53;
        end_refs = p + D.21264;
        goto <D.20595>;
        <D.20594>:
        {
          void * __old;

          __old = *p;
          if (__old != 0B) goto <D.21265>; else goto <D.21266>;
          <D.21265>:
          split_nursery_serial_copy_object_from_obj (p, queue);
          if (0 != 0) goto <D.21267>; else goto <D.21268>;
          <D.21267>:
          D.21269 = *p;
          if (D.21269 != __old) goto <D.21270>; else goto <D.21271>;
          <D.21270>:
          gc_debug_file.49 = gc_debug_file;
          D.21269 = *p;
          fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", p, D.21269, __old);
          gc_debug_file.49 = gc_debug_file;
          fflush (gc_debug_file.49);
          <D.21271>:
          <D.21268>:
          <D.21266>:
        }
        p = p + 4;
        <D.20595>:
        if (p < end_refs) goto <D.20594>; else goto <D.20596>;
        <D.20596>:
      }
      goto <D.21272>;
      <D.21261>:
      if (etype == 32768) goto <D.21273>; else goto <D.21274>;
      <D.21273>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.21216 = desc >> 16;
        D.21275 = (int) D.21216;
        offset = D.21275 & 255;
        D.21219 = desc >> 24;
        num_refs = (int) D.21219;
        e_start = start + 16;
        D.21262 = MEM[(struct MonoArray *)start].max_length;
        el_size.53 = (unsigned int) el_size;
        D.21264 = D.21262 * el_size.53;
        e_end = e_start + D.21264;
        goto <D.20608>;
        <D.20607>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.54 = (unsigned int) offset;
          D.21277 = offset.54 * 4;
          p = p + D.21277;
          i = 0;
          goto <D.20605>;
          <D.20604>:
          {
            void * __old;

            i.55 = (unsigned int) i;
            D.21279 = i.55 * 4;
            D.21280 = p + D.21279;
            __old = *D.21280;
            if (__old != 0B) goto <D.21281>; else goto <D.21282>;
            <D.21281>:
            i.55 = (unsigned int) i;
            D.21279 = i.55 * 4;
            D.21280 = p + D.21279;
            split_nursery_serial_copy_object_from_obj (D.21280, queue);
            if (0 != 0) goto <D.21283>; else goto <D.21284>;
            <D.21283>:
            i.55 = (unsigned int) i;
            D.21279 = i.55 * 4;
            D.21280 = p + D.21279;
            D.21285 = *D.21280;
            if (D.21285 != __old) goto <D.21286>; else goto <D.21287>;
            <D.21286>:
            gc_debug_file.49 = gc_debug_file;
            i.55 = (unsigned int) i;
            D.21279 = i.55 * 4;
            D.21280 = p + D.21279;
            i.55 = (unsigned int) i;
            D.21279 = i.55 * 4;
            D.21280 = p + D.21279;
            D.21285 = *D.21280;
            fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", D.21280, D.21285, __old);
            gc_debug_file.49 = gc_debug_file;
            fflush (gc_debug_file.49);
            <D.21287>:
            <D.21284>:
            <D.21282>:
          }
          i = i + 1;
          <D.20605>:
          if (i < num_refs) goto <D.20604>; else goto <D.20606>;
          <D.20606>:
          el_size.56 = (sizetype) el_size;
          e_start = e_start + el_size.56;
        }
        <D.20608>:
        if (e_start < e_end) goto <D.20607>; else goto <D.20609>;
        <D.20609>:
      }
      goto <D.21289>;
      <D.21274>:
      if (etype == 49152) goto <D.21290>; else goto <D.21291>;
      <D.21290>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.21262 = MEM[(struct MonoArray *)start].max_length;
        el_size.53 = (unsigned int) el_size;
        D.21264 = D.21262 * el_size.53;
        e_end = e_start + D.21264;
        goto <D.20619>;
        <D.20618>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.20616>;
          <D.20615>:
          D.21292 = _bmap & 1;
          if (D.21292 != 0) goto <D.21293>; else goto <D.21294>;
          <D.21293>:
          {
            void * __old;

            __old = *p;
            if (__old != 0B) goto <D.21295>; else goto <D.21296>;
            <D.21295>:
            split_nursery_serial_copy_object_from_obj (p, queue);
            if (0 != 0) goto <D.21297>; else goto <D.21298>;
            <D.21297>:
            D.21299 = *p;
            if (D.21299 != __old) goto <D.21300>; else goto <D.21301>;
            <D.21300>:
            gc_debug_file.49 = gc_debug_file;
            D.21299 = *p;
            fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", p, D.21299, __old);
            gc_debug_file.49 = gc_debug_file;
            fflush (gc_debug_file.49);
            <D.21301>:
            <D.21298>:
            <D.21296>:
          }
          <D.21294>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.20616>:
          if (_bmap != 0) goto <D.20615>; else goto <D.20617>;
          <D.20617>:
          el_size.56 = (sizetype) el_size;
          e_start = e_start + el_size.56;
        }
        <D.20619>:
        if (e_start < e_end) goto <D.20618>; else goto <D.20620>;
        <D.20620>:
      }
      <D.21291>:
      <D.21289>:
      <D.21272>:
    }
    <D.21256>:
    goto <D.20577>;
    <D.20621>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.20626>;
      <D.20625>:
      D.21302 = _bmap & 1;
      if (D.21302 != 0) goto <D.21303>; else goto <D.21304>;
      <D.21303>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.21305>; else goto <D.21306>;
        <D.21305>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.21307>; else goto <D.21308>;
        <D.21307>:
        D.21309 = *_objptr;
        if (D.21309 != __old) goto <D.21310>; else goto <D.21311>;
        <D.21310>:
        gc_debug_file.49 = gc_debug_file;
        D.21309 = *_objptr;
        fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21309, __old);
        gc_debug_file.49 = gc_debug_file;
        fflush (gc_debug_file.49);
        <D.21311>:
        <D.21308>:
        <D.21306>:
      }
      <D.21304>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20626>:
      if (_bmap != 0) goto <D.20625>; else goto <D.20627>;
      <D.20627>:
    }
    goto <D.20577>;
    <D.20628>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.21312 = *bitmap_data;
      D.21313 = D.21312 + 4294967295;
      bwords = (int) D.21313;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.21314>; else goto <D.21315>;
      <D.21314>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.21316 = myobj->vtable;
        D.21317 = D.21316->klass;
        D.21318 = D.21317->name_space;
        D.21316 = myobj->vtable;
        D.21317 = D.21316->klass;
        D.21319 = D.21317->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21318, D.21319);
      }
      <D.21315>:
      goto <D.20640>;
      <D.20639>:
      {
        gsize _bmap;

        bitmap_data.57 = bitmap_data;
        bitmap_data = bitmap_data.57 + 4;
        _bmap = *bitmap_data.57;
        _objptr = start_run;
        goto <D.20637>;
        <D.20636>:
        D.21321 = _bmap & 1;
        if (D.21321 != 0) goto <D.21322>; else goto <D.21323>;
        <D.21322>:
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.21324>; else goto <D.21325>;
          <D.21324>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.21326>; else goto <D.21327>;
          <D.21326>:
          D.21328 = *_objptr;
          if (D.21328 != __old) goto <D.21329>; else goto <D.21330>;
          <D.21329>:
          gc_debug_file.49 = gc_debug_file;
          D.21328 = *_objptr;
          fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21328, __old);
          gc_debug_file.49 = gc_debug_file;
          fflush (gc_debug_file.49);
          <D.21330>:
          <D.21327>:
          <D.21325>:
        }
        <D.21323>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.20637>:
        if (_bmap != 0) goto <D.20636>; else goto <D.20638>;
        <D.20638>:
        start_run = start_run + 128;
      }
      <D.20640>:
      bwords.58 = bwords;
      bwords = bwords.58 + -1;
      if (bwords.58 > 0) goto <D.20639>; else goto <D.20641>;
      <D.20641>:
    }
    goto <D.20577>;
    <D.20642>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.21332 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.21332);
      mbitmap_data.59 = mbitmap_data;
      mbitmap_data = mbitmap_data.59 + 4;
      D.21334 = *mbitmap_data.59;
      D.21335 = D.21334 + 4294967295;
      mbwords = (int) D.21335;
      D.21336 = vt->klass;
      el_size = mono_array_element_size (D.21336);
      e_start = start + 16;
      D.21262 = MEM[(struct MonoArray *)start].max_length;
      el_size.60 = (unsigned int) el_size;
      D.21338 = D.21262 * el_size.60;
      e_end = e_start + D.21338;
      if (0 != 0) goto <D.21339>; else goto <D.21340>;
      <D.21339>:
      D.21332 = vt->desc;
      D.21336 = vt->klass;
      D.21341 = D.21336->name_space;
      D.21336 = vt->klass;
      D.21342 = D.21336->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.21332, D.21341, D.21342);
      <D.21340>:
      goto <D.20661>;
      <D.20660>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.61 = bitmap_data;
          bitmap_data = bitmap_data.61 + 4;
          _bmap = *bitmap_data.61;
          start_run = _objptr;
          goto <D.20655>;
          <D.20654>:
          D.21344 = _bmap & 1;
          if (D.21344 != 0) goto <D.21345>; else goto <D.21346>;
          <D.21345>:
          {
            void * __old;

            __old = *_objptr;
            if (__old != 0B) goto <D.21347>; else goto <D.21348>;
            <D.21347>:
            split_nursery_serial_copy_object_from_obj (_objptr, queue);
            if (0 != 0) goto <D.21349>; else goto <D.21350>;
            <D.21349>:
            D.21351 = *_objptr;
            if (D.21351 != __old) goto <D.21352>; else goto <D.21353>;
            <D.21352>:
            gc_debug_file.49 = gc_debug_file;
            D.21351 = *_objptr;
            fprintf (gc_debug_file.49, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21351, __old);
            gc_debug_file.49 = gc_debug_file;
            fflush (gc_debug_file.49);
            <D.21353>:
            <D.21350>:
            <D.21348>:
          }
          <D.21346>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.20655>:
          if (_bmap != 0) goto <D.20654>; else goto <D.20656>;
          <D.20656>:
          _objptr = start_run + 128;
        }
        <D.20658>:
        bwords.62 = bwords;
        bwords = bwords.62 + 4294967295;
        if (bwords.62 != 0) goto <D.20657>; else goto <D.20659>;
        <D.20659>:
        el_size.63 = (sizetype) el_size;
        e_start = e_start + el_size.63;
      }
      <D.20661>:
      if (e_start < e_end) goto <D.20660>; else goto <D.20662>;
      <D.20662>:
    }
    goto <D.20577>;
    <D.20663>:
    goto <D.20577>;
    <D.20664>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.20577>:
  }
}


split_nursery_parallel_scan_vtype (char * start, mword desc, struct SgenGrayQueue * queue)
{
  unsigned int D.21357;
  unsigned int D.21358;
  unsigned int D.21361;
  unsigned int D.21362;
  unsigned int D.21363;
  unsigned int D.21364;
  unsigned int D.21365;
  struct FILE * gc_debug_file.64;
  void * D.21373;
  int iftmp.65;
  int D.21377;
  int D.21379;
  _Bool D.21381;
  long int D.21382;
  long int D.21383;
  int iftmp.66;
  int D.21395;
  int D.21397;
  _Bool D.21399;
  long int D.21400;
  long int D.21401;
  unsigned int _index.67;
  unsigned int D.21405;
  int D.21406;
  void * D.21413;
  int iftmp.68;
  int D.21417;
  int D.21419;
  _Bool D.21421;
  long int D.21422;
  long int D.21423;
  unsigned int _index.69;
  unsigned int D.21427;
  int D.21428;
  int iftmp.70;
  int D.21438;
  int D.21440;
  _Bool D.21442;
  long int D.21443;
  long int D.21444;
  unsigned int D.21447;
  unsigned int D.21450;
  int D.21451;
  int desc.71;
  unsigned int D.21455;
  unsigned int el_size.72;
  unsigned int D.21457;
  void * D.21464;
  int iftmp.73;
  int D.21468;
  int D.21470;
  _Bool D.21472;
  long int D.21473;
  long int D.21474;
  int D.21480;
  unsigned int offset.74;
  unsigned int D.21482;
  unsigned int i.75;
  unsigned int D.21484;
  void * * D.21485;
  void * D.21492;
  int iftmp.76;
  int D.21496;
  void * D.21498;
  int D.21499;
  _Bool D.21501;
  long int D.21502;
  long int D.21503;
  void * D.21506;
  sizetype el_size.77;
  unsigned int D.21511;
  void * D.21520;
  int iftmp.78;
  int D.21524;
  int D.21526;
  _Bool D.21528;
  long int D.21529;
  long int D.21530;
  unsigned int D.21533;
  void * D.21542;
  int iftmp.79;
  int D.21546;
  int D.21548;
  _Bool D.21550;
  long int D.21551;
  long int D.21552;
  unsigned int D.21555;
  unsigned int D.21556;
  struct MonoVTable * D.21559;
  struct MonoClass * D.21560;
  const char * D.21561;
  const char * D.21562;
  gsize * bitmap_data.80;
  unsigned int D.21564;
  void * D.21573;
  int iftmp.81;
  int D.21577;
  int D.21579;
  _Bool D.21581;
  long int D.21582;
  long int D.21583;
  int bwords.82;

  start = start + 4294967288;
  D.21357 = desc & 7;
  switch (D.21357) <default: <D.20562>, case 1: <D.20479>, case 2: <D.20490>, case 3: <D.20546>, case 4: <D.20502>, case 5: <D.20538>, case 7: <D.20561>>
  <D.20479>:
  D.21358 = desc & 4294901760;
  if (D.21358 != 0) goto <D.21359>; else goto <D.21360>;
  <D.21359>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.21361 = desc >> 16;
    D.21362 = D.21361 & 255;
    D.21363 = D.21362 * 4;
    _objptr = _objptr + D.21363;
    D.21364 = desc >> 24;
    D.21365 = D.21364 * 4;
    _objptr_end = _objptr + D.21365;
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.21366>; else goto <D.21367>;
      <D.21366>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.21368>; else goto <D.21369>;
      <D.21368>:
      if (__old != __copy) goto <D.21370>; else goto <D.21371>;
      <D.21370>:
      gc_debug_file.64 = gc_debug_file;
      D.21373 = *_objptr;
      fprintf (gc_debug_file.64, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21373, __old);
      gc_debug_file.64 = gc_debug_file;
      fflush (gc_debug_file.64);
      <D.21371>:
      <D.21369>:
      D.21377 = sgen_ptr_in_nursery (__copy);
      if (D.21377 != 0) goto <D.21378>; else goto <D.21375>;
      <D.21378>:
      D.21379 = sgen_ptr_in_nursery (_objptr);
      if (D.21379 == 0) goto <D.21380>; else goto <D.21375>;
      <D.21380>:
      iftmp.65 = 1;
      goto <D.21376>;
      <D.21375>:
      iftmp.65 = 0;
      <D.21376>:
      D.21381 = iftmp.65 != 0;
      D.21382 = (long int) D.21381;
      D.21383 = __builtin_expect (D.21382, 0);
      if (D.21383 != 0) goto <D.21384>; else goto <D.21385>;
      <D.21384>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.21385>:
      <D.21367>:
    }
    _objptr = _objptr + 4;
    goto <D.20487>;
    <D.20486>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.21386>; else goto <D.21387>;
      <D.21386>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.21388>; else goto <D.21389>;
      <D.21388>:
      if (__old != __copy) goto <D.21390>; else goto <D.21391>;
      <D.21390>:
      gc_debug_file.64 = gc_debug_file;
      D.21373 = *_objptr;
      fprintf (gc_debug_file.64, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21373, __old);
      gc_debug_file.64 = gc_debug_file;
      fflush (gc_debug_file.64);
      <D.21391>:
      <D.21389>:
      D.21395 = sgen_ptr_in_nursery (__copy);
      if (D.21395 != 0) goto <D.21396>; else goto <D.21393>;
      <D.21396>:
      D.21397 = sgen_ptr_in_nursery (_objptr);
      if (D.21397 == 0) goto <D.21398>; else goto <D.21393>;
      <D.21398>:
      iftmp.66 = 1;
      goto <D.21394>;
      <D.21393>:
      iftmp.66 = 0;
      <D.21394>:
      D.21399 = iftmp.66 != 0;
      D.21400 = (long int) D.21399;
      D.21401 = __builtin_expect (D.21400, 0);
      if (D.21401 != 0) goto <D.21402>; else goto <D.21403>;
      <D.21402>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.21403>:
      <D.21387>:
    }
    _objptr = _objptr + 4;
    <D.20487>:
    if (_objptr < _objptr_end) goto <D.20486>; else goto <D.20488>;
    <D.20488>:
  }
  <D.21360>:
  goto <D.20489>;
  <D.20490>:
  {
    void * * _objptr;
    gsize _bmap;

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

      _index = __builtin_ctz (_bmap);
      _index.67 = (unsigned int) _index;
      D.21405 = _index.67 * 4;
      _objptr = _objptr + D.21405;
      D.21406 = _index + 1;
      _bmap = _bmap >> D.21406;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21407>; else goto <D.21408>;
        <D.21407>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21409>; else goto <D.21410>;
        <D.21409>:
        if (__old != __copy) goto <D.21411>; else goto <D.21412>;
        <D.21411>:
        gc_debug_file.64 = gc_debug_file;
        D.21413 = *_objptr;
        fprintf (gc_debug_file.64, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21413, __old);
        gc_debug_file.64 = gc_debug_file;
        fflush (gc_debug_file.64);
        <D.21412>:
        <D.21410>:
        D.21417 = sgen_ptr_in_nursery (__copy);
        if (D.21417 != 0) goto <D.21418>; else goto <D.21415>;
        <D.21418>:
        D.21419 = sgen_ptr_in_nursery (_objptr);
        if (D.21419 == 0) goto <D.21420>; else goto <D.21415>;
        <D.21420>:
        iftmp.68 = 1;
        goto <D.21416>;
        <D.21415>:
        iftmp.68 = 0;
        <D.21416>:
        D.21421 = iftmp.68 != 0;
        D.21422 = (long int) D.21421;
        D.21423 = __builtin_expect (D.21422, 0);
        if (D.21423 != 0) goto <D.21424>; else goto <D.21425>;
        <D.21424>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21425>:
        <D.21408>:
      }
      _objptr = _objptr + 4;
    }
    goto <D.20500>;
    <D.20499>:
    {
      int _index;

      _index = __builtin_ctz (_bmap);
      _index.69 = (unsigned int) _index;
      D.21427 = _index.69 * 4;
      _objptr = _objptr + D.21427;
      D.21428 = _index + 1;
      _bmap = _bmap >> D.21428;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21429>; else goto <D.21430>;
        <D.21429>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21431>; else goto <D.21432>;
        <D.21431>:
        if (__old != __copy) goto <D.21433>; else goto <D.21434>;
        <D.21433>:
        gc_debug_file.64 = gc_debug_file;
        D.21413 = *_objptr;
        fprintf (gc_debug_file.64, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21413, __old);
        gc_debug_file.64 = gc_debug_file;
        fflush (gc_debug_file.64);
        <D.21434>:
        <D.21432>:
        D.21438 = sgen_ptr_in_nursery (__copy);
        if (D.21438 != 0) goto <D.21439>; else goto <D.21436>;
        <D.21439>:
        D.21440 = sgen_ptr_in_nursery (_objptr);
        if (D.21440 == 0) goto <D.21441>; else goto <D.21436>;
        <D.21441>:
        iftmp.70 = 1;
        goto <D.21437>;
        <D.21436>:
        iftmp.70 = 0;
        <D.21437>:
        D.21442 = iftmp.70 != 0;
        D.21443 = (long int) D.21442;
        D.21444 = __builtin_expect (D.21443, 0);
        if (D.21444 != 0) goto <D.21445>; else goto <D.21446>;
        <D.21445>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21446>:
        <D.21430>:
      }
      _objptr = _objptr + 4;
    }
    <D.20500>:
    if (_bmap != 0) goto <D.20499>; else goto <D.20501>;
    <D.20501>:
  }
  goto <D.20489>;
  <D.20502>:
  D.21447 = desc & 4294950912;
  if (D.21447 != 0) goto <D.21448>; else goto <D.21449>;
  <D.21448>:
  {
    int el_size;
    int etype;

    D.21450 = desc >> 3;
    D.21451 = (int) D.21450;
    el_size = D.21451 & 1023;
    desc.71 = (int) desc;
    etype = desc.71 & 49152;
    if (etype == 16384) goto <D.21453>; else goto <D.21454>;
    <D.21453>:
    {
      void * * p;
      void * * end_refs;

      p = start + 16;
      D.21455 = MEM[(struct MonoArray *)start].max_length;
      el_size.72 = (unsigned int) el_size;
      D.21457 = D.21455 * el_size.72;
      end_refs = p + D.21457;
      goto <D.20510>;
      <D.20509>:
      {
        void * __old;
        void * __copy;

        __old = *p;
        if (__old != 0B) goto <D.21458>; else goto <D.21459>;
        <D.21458>:
        split_nursery_parallel_copy_object (p, queue);
        __copy = *p;
        if (0 != 0) goto <D.21460>; else goto <D.21461>;
        <D.21460>:
        if (__old != __copy) goto <D.21462>; else goto <D.21463>;
        <D.21462>:
        gc_debug_file.64 = gc_debug_file;
        D.21464 = *p;
        fprintf (gc_debug_file.64, "Overwrote field at %p with %p (was: %p)\n", p, D.21464, __old);
        gc_debug_file.64 = gc_debug_file;
        fflush (gc_debug_file.64);
        <D.21463>:
        <D.21461>:
        D.21468 = sgen_ptr_in_nursery (__copy);
        if (D.21468 != 0) goto <D.21469>; else goto <D.21466>;
        <D.21469>:
        D.21470 = sgen_ptr_in_nursery (p);
        if (D.21470 == 0) goto <D.21471>; else goto <D.21466>;
        <D.21471>:
        iftmp.73 = 1;
        goto <D.21467>;
        <D.21466>:
        iftmp.73 = 0;
        <D.21467>:
        D.21472 = iftmp.73 != 0;
        D.21473 = (long int) D.21472;
        D.21474 = __builtin_expect (D.21473, 0);
        if (D.21474 != 0) goto <D.21475>; else goto <D.21476>;
        <D.21475>:
        sgen_add_to_global_remset (p, __copy);
        <D.21476>:
        <D.21459>:
      }
      p = p + 4;
      <D.20510>:
      if (p < end_refs) goto <D.20509>; else goto <D.20511>;
      <D.20511>:
    }
    goto <D.21477>;
    <D.21454>:
    if (etype == 32768) goto <D.21478>; else goto <D.21479>;
    <D.21478>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.21361 = desc >> 16;
      D.21480 = (int) D.21361;
      offset = D.21480 & 255;
      D.21364 = desc >> 24;
      num_refs = (int) D.21364;
      e_start = start + 16;
      D.21455 = MEM[(struct MonoArray *)start].max_length;
      el_size.72 = (unsigned int) el_size;
      D.21457 = D.21455 * el_size.72;
      e_end = e_start + D.21457;
      goto <D.20524>;
      <D.20523>:
      {
        void * * p;
        int i;

        p = e_start;
        offset.74 = (unsigned int) offset;
        D.21482 = offset.74 * 4;
        p = p + D.21482;
        i = 0;
        goto <D.20521>;
        <D.20520>:
        {
          void * __old;
          void * __copy;

          i.75 = (unsigned int) i;
          D.21484 = i.75 * 4;
          D.21485 = p + D.21484;
          __old = *D.21485;
          if (__old != 0B) goto <D.21486>; else goto <D.21487>;
          <D.21486>:
          i.75 = (unsigned int) i;
          D.21484 = i.75 * 4;
          D.21485 = p + D.21484;
          split_nursery_parallel_copy_object (D.21485, queue);
          i.75 = (unsigned int) i;
          D.21484 = i.75 * 4;
          D.21485 = p + D.21484;
          __copy = *D.21485;
          if (0 != 0) goto <D.21488>; else goto <D.21489>;
          <D.21488>:
          if (__old != __copy) goto <D.21490>; else goto <D.21491>;
          <D.21490>:
          gc_debug_file.64 = gc_debug_file;
          i.75 = (unsigned int) i;
          D.21484 = i.75 * 4;
          D.21485 = p + D.21484;
          i.75 = (unsigned int) i;
          D.21484 = i.75 * 4;
          D.21485 = p + D.21484;
          D.21492 = *D.21485;
          fprintf (gc_debug_file.64, "Overwrote field at %p with %p (was: %p)\n", D.21485, D.21492, __old);
          gc_debug_file.64 = gc_debug_file;
          fflush (gc_debug_file.64);
          <D.21491>:
          <D.21489>:
          D.21496 = sgen_ptr_in_nursery (__copy);
          if (D.21496 != 0) goto <D.21497>; else goto <D.21494>;
          <D.21497>:
          i.75 = (unsigned int) i;
          D.21484 = i.75 * 4;
          D.21498 = p + D.21484;
          D.21499 = sgen_ptr_in_nursery (D.21498);
          if (D.21499 == 0) goto <D.21500>; else goto <D.21494>;
          <D.21500>:
          iftmp.76 = 1;
          goto <D.21495>;
          <D.21494>:
          iftmp.76 = 0;
          <D.21495>:
          D.21501 = iftmp.76 != 0;
          D.21502 = (long int) D.21501;
          D.21503 = __builtin_expect (D.21502, 0);
          if (D.21503 != 0) goto <D.21504>; else goto <D.21505>;
          <D.21504>:
          i.75 = (unsigned int) i;
          D.21484 = i.75 * 4;
          D.21506 = p + D.21484;
          sgen_add_to_global_remset (D.21506, __copy);
          <D.21505>:
          <D.21487>:
        }
        i = i + 1;
        <D.20521>:
        if (i < num_refs) goto <D.20520>; else goto <D.20522>;
        <D.20522>:
        el_size.77 = (sizetype) el_size;
        e_start = e_start + el_size.77;
      }
      <D.20524>:
      if (e_start < e_end) goto <D.20523>; else goto <D.20525>;
      <D.20525>:
    }
    goto <D.21508>;
    <D.21479>:
    if (etype == 49152) goto <D.21509>; else goto <D.21510>;
    <D.21509>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 16;
      D.21455 = MEM[(struct MonoArray *)start].max_length;
      el_size.72 = (unsigned int) el_size;
      D.21457 = D.21455 * el_size.72;
      e_end = e_start + D.21457;
      goto <D.20536>;
      <D.20535>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.20533>;
        <D.20532>:
        D.21511 = _bmap & 1;
        if (D.21511 != 0) goto <D.21512>; else goto <D.21513>;
        <D.21512>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.21514>; else goto <D.21515>;
          <D.21514>:
          split_nursery_parallel_copy_object (p, queue);
          __copy = *p;
          if (0 != 0) goto <D.21516>; else goto <D.21517>;
          <D.21516>:
          if (__old != __copy) goto <D.21518>; else goto <D.21519>;
          <D.21518>:
          gc_debug_file.64 = gc_debug_file;
          D.21520 = *p;
          fprintf (gc_debug_file.64, "Overwrote field at %p with %p (was: %p)\n", p, D.21520, __old);
          gc_debug_file.64 = gc_debug_file;
          fflush (gc_debug_file.64);
          <D.21519>:
          <D.21517>:
          D.21524 = sgen_ptr_in_nursery (__copy);
          if (D.21524 != 0) goto <D.21525>; else goto <D.21522>;
          <D.21525>:
          D.21526 = sgen_ptr_in_nursery (p);
          if (D.21526 == 0) goto <D.21527>; else goto <D.21522>;
          <D.21527>:
          iftmp.78 = 1;
          goto <D.21523>;
          <D.21522>:
          iftmp.78 = 0;
          <D.21523>:
          D.21528 = iftmp.78 != 0;
          D.21529 = (long int) D.21528;
          D.21530 = __builtin_expect (D.21529, 0);
          if (D.21530 != 0) goto <D.21531>; else goto <D.21532>;
          <D.21531>:
          sgen_add_to_global_remset (p, __copy);
          <D.21532>:
          <D.21515>:
        }
        <D.21513>:
        _bmap = _bmap >> 1;
        p = p + 4;
        <D.20533>:
        if (_bmap != 0) goto <D.20532>; else goto <D.20534>;
        <D.20534>:
        el_size.77 = (sizetype) el_size;
        e_start = e_start + el_size.77;
      }
      <D.20536>:
      if (e_start < e_end) goto <D.20535>; else goto <D.20537>;
      <D.20537>:
    }
    <D.21510>:
    <D.21508>:
    <D.21477>:
  }
  <D.21449>:
  goto <D.20489>;
  <D.20538>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 3;
    _objptr = _objptr + 8;
    goto <D.20544>;
    <D.20543>:
    D.21533 = _bmap & 1;
    if (D.21533 != 0) goto <D.21534>; else goto <D.21535>;
    <D.21534>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.21536>; else goto <D.21537>;
      <D.21536>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.21538>; else goto <D.21539>;
      <D.21538>:
      if (__old != __copy) goto <D.21540>; else goto <D.21541>;
      <D.21540>:
      gc_debug_file.64 = gc_debug_file;
      D.21542 = *_objptr;
      fprintf (gc_debug_file.64, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21542, __old);
      gc_debug_file.64 = gc_debug_file;
      fflush (gc_debug_file.64);
      <D.21541>:
      <D.21539>:
      D.21546 = sgen_ptr_in_nursery (__copy);
      if (D.21546 != 0) goto <D.21547>; else goto <D.21544>;
      <D.21547>:
      D.21548 = sgen_ptr_in_nursery (_objptr);
      if (D.21548 == 0) goto <D.21549>; else goto <D.21544>;
      <D.21549>:
      iftmp.79 = 1;
      goto <D.21545>;
      <D.21544>:
      iftmp.79 = 0;
      <D.21545>:
      D.21550 = iftmp.79 != 0;
      D.21551 = (long int) D.21550;
      D.21552 = __builtin_expect (D.21551, 0);
      if (D.21552 != 0) goto <D.21553>; else goto <D.21554>;
      <D.21553>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.21554>:
      <D.21537>:
    }
    <D.21535>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 4;
    <D.20544>:
    if (_bmap != 0) goto <D.20543>; else goto <D.20545>;
    <D.20545>:
  }
  goto <D.20489>;
  <D.20546>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.21555 = *bitmap_data;
    D.21556 = D.21555 + 4294967295;
    bwords = (int) D.21556;
    start_run = _objptr;
    bitmap_data = bitmap_data + 4;
    if (0 != 0) goto <D.21557>; else goto <D.21558>;
    <D.21557>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.21559 = myobj->vtable;
      D.21560 = D.21559->klass;
      D.21561 = D.21560->name_space;
      D.21559 = myobj->vtable;
      D.21560 = D.21559->klass;
      D.21562 = D.21560->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21561, D.21562);
    }
    <D.21558>:
    goto <D.20559>;
    <D.20558>:
    {
      gsize _bmap;

      bitmap_data.80 = bitmap_data;
      bitmap_data = bitmap_data.80 + 4;
      _bmap = *bitmap_data.80;
      _objptr = start_run;
      goto <D.20556>;
      <D.20555>:
      D.21564 = _bmap & 1;
      if (D.21564 != 0) goto <D.21565>; else goto <D.21566>;
      <D.21565>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21567>; else goto <D.21568>;
        <D.21567>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21569>; else goto <D.21570>;
        <D.21569>:
        if (__old != __copy) goto <D.21571>; else goto <D.21572>;
        <D.21571>:
        gc_debug_file.64 = gc_debug_file;
        D.21573 = *_objptr;
        fprintf (gc_debug_file.64, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21573, __old);
        gc_debug_file.64 = gc_debug_file;
        fflush (gc_debug_file.64);
        <D.21572>:
        <D.21570>:
        D.21577 = sgen_ptr_in_nursery (__copy);
        if (D.21577 != 0) goto <D.21578>; else goto <D.21575>;
        <D.21578>:
        D.21579 = sgen_ptr_in_nursery (_objptr);
        if (D.21579 == 0) goto <D.21580>; else goto <D.21575>;
        <D.21580>:
        iftmp.81 = 1;
        goto <D.21576>;
        <D.21575>:
        iftmp.81 = 0;
        <D.21576>:
        D.21581 = iftmp.81 != 0;
        D.21582 = (long int) D.21581;
        D.21583 = __builtin_expect (D.21582, 0);
        if (D.21583 != 0) goto <D.21584>; else goto <D.21585>;
        <D.21584>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21585>:
        <D.21568>:
      }
      <D.21566>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20556>:
      if (_bmap != 0) goto <D.20555>; else goto <D.20557>;
      <D.20557>:
      start_run = start_run + 128;
    }
    <D.20559>:
    bwords.82 = bwords;
    bwords = bwords.82 + -1;
    if (bwords.82 > 0) goto <D.20558>; else goto <D.20560>;
    <D.20560>:
  }
  goto <D.20489>;
  <D.20561>:
  goto <D.20489>;
  <D.20562>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.20489>:
}


split_nursery_parallel_scan_object (char * start, struct SgenGrayQueue * queue)
{
  unsigned int D.21588;
  unsigned int D.21589;
  unsigned int D.21590;
  unsigned int D.21591;
  unsigned int D.21594;
  unsigned int D.21595;
  unsigned int D.21596;
  unsigned int D.21597;
  unsigned int D.21598;
  struct FILE * gc_debug_file.83;
  void * D.21606;
  int iftmp.84;
  int D.21610;
  int D.21612;
  _Bool D.21614;
  long int D.21615;
  long int D.21616;
  int iftmp.85;
  int D.21628;
  int D.21630;
  _Bool D.21632;
  long int D.21633;
  long int D.21634;
  unsigned int _index.86;
  unsigned int D.21638;
  int D.21639;
  void * D.21646;
  int iftmp.87;
  int D.21650;
  int D.21652;
  _Bool D.21654;
  long int D.21655;
  long int D.21656;
  unsigned int _index.88;
  unsigned int D.21660;
  int D.21661;
  int iftmp.89;
  int D.21671;
  int D.21673;
  _Bool D.21675;
  long int D.21676;
  long int D.21677;
  unsigned int D.21680;
  unsigned int D.21683;
  int D.21684;
  int desc.90;
  unsigned int D.21688;
  unsigned int el_size.91;
  unsigned int D.21690;
  void * D.21697;
  int iftmp.92;
  int D.21701;
  int D.21703;
  _Bool D.21705;
  long int D.21706;
  long int D.21707;
  int D.21713;
  unsigned int offset.93;
  unsigned int D.21715;
  unsigned int i.94;
  unsigned int D.21717;
  void * * D.21718;
  void * D.21725;
  int iftmp.95;
  int D.21729;
  void * D.21731;
  int D.21732;
  _Bool D.21734;
  long int D.21735;
  long int D.21736;
  void * D.21739;
  sizetype el_size.96;
  unsigned int D.21744;
  void * D.21753;
  int iftmp.97;
  int D.21757;
  int D.21759;
  _Bool D.21761;
  long int D.21762;
  long int D.21763;
  unsigned int D.21766;
  void * D.21775;
  int iftmp.98;
  int D.21779;
  int D.21781;
  _Bool D.21783;
  long int D.21784;
  long int D.21785;
  unsigned int D.21788;
  unsigned int D.21789;
  struct MonoVTable * D.21792;
  struct MonoClass * D.21793;
  const char * D.21794;
  const char * D.21795;
  gsize * bitmap_data.99;
  unsigned int D.21797;
  void * D.21806;
  int iftmp.100;
  int D.21810;
  int D.21812;
  _Bool D.21814;
  long int D.21815;
  long int D.21816;
  int bwords.101;
  unsigned int D.21820;
  gsize * mbitmap_data.102;
  unsigned int D.21822;
  unsigned int D.21823;
  struct MonoClass * D.21824;
  unsigned int el_size.103;
  unsigned int D.21826;
  const char * D.21829;
  const char * D.21830;
  gsize * bitmap_data.104;
  unsigned int D.21832;
  void * D.21841;
  int iftmp.105;
  int D.21845;
  int D.21847;
  _Bool D.21849;
  long int D.21850;
  long int D.21851;
  unsigned int bwords.106;
  sizetype el_size.107;

  {
    struct GCVTable * vt;
    mword desc;

    D.21588 = MEM[(mword *)start];
    D.21589 = D.21588 & 4294967292;
    vt = (struct GCVTable *) D.21589;
    desc = vt->desc;
    D.21590 = desc & 7;
    switch (D.21590) <default: <D.20473>, case 1: <D.20368>, case 2: <D.20379>, case 3: <D.20435>, case 4: <D.20391>, case 5: <D.20427>, case 6: <D.20450>, case 7: <D.20472>>
    <D.20368>:
    D.21591 = desc & 4294901760;
    if (D.21591 != 0) goto <D.21592>; else goto <D.21593>;
    <D.21592>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.21594 = desc >> 16;
      D.21595 = D.21594 & 255;
      D.21596 = D.21595 * 4;
      _objptr = _objptr + D.21596;
      D.21597 = desc >> 24;
      D.21598 = D.21597 * 4;
      _objptr_end = _objptr + D.21598;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21599>; else goto <D.21600>;
        <D.21599>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21601>; else goto <D.21602>;
        <D.21601>:
        if (__old != __copy) goto <D.21603>; else goto <D.21604>;
        <D.21603>:
        gc_debug_file.83 = gc_debug_file;
        D.21606 = *_objptr;
        fprintf (gc_debug_file.83, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21606, __old);
        gc_debug_file.83 = gc_debug_file;
        fflush (gc_debug_file.83);
        <D.21604>:
        <D.21602>:
        D.21610 = sgen_ptr_in_nursery (__copy);
        if (D.21610 != 0) goto <D.21611>; else goto <D.21608>;
        <D.21611>:
        D.21612 = sgen_ptr_in_nursery (_objptr);
        if (D.21612 == 0) goto <D.21613>; else goto <D.21608>;
        <D.21613>:
        iftmp.84 = 1;
        goto <D.21609>;
        <D.21608>:
        iftmp.84 = 0;
        <D.21609>:
        D.21614 = iftmp.84 != 0;
        D.21615 = (long int) D.21614;
        D.21616 = __builtin_expect (D.21615, 0);
        if (D.21616 != 0) goto <D.21617>; else goto <D.21618>;
        <D.21617>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21618>:
        <D.21600>:
      }
      _objptr = _objptr + 4;
      goto <D.20376>;
      <D.20375>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21619>; else goto <D.21620>;
        <D.21619>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21621>; else goto <D.21622>;
        <D.21621>:
        if (__old != __copy) goto <D.21623>; else goto <D.21624>;
        <D.21623>:
        gc_debug_file.83 = gc_debug_file;
        D.21606 = *_objptr;
        fprintf (gc_debug_file.83, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21606, __old);
        gc_debug_file.83 = gc_debug_file;
        fflush (gc_debug_file.83);
        <D.21624>:
        <D.21622>:
        D.21628 = sgen_ptr_in_nursery (__copy);
        if (D.21628 != 0) goto <D.21629>; else goto <D.21626>;
        <D.21629>:
        D.21630 = sgen_ptr_in_nursery (_objptr);
        if (D.21630 == 0) goto <D.21631>; else goto <D.21626>;
        <D.21631>:
        iftmp.85 = 1;
        goto <D.21627>;
        <D.21626>:
        iftmp.85 = 0;
        <D.21627>:
        D.21632 = iftmp.85 != 0;
        D.21633 = (long int) D.21632;
        D.21634 = __builtin_expect (D.21633, 0);
        if (D.21634 != 0) goto <D.21635>; else goto <D.21636>;
        <D.21635>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21636>:
        <D.21620>:
      }
      _objptr = _objptr + 4;
      <D.20376>:
      if (_objptr < _objptr_end) goto <D.20375>; else goto <D.20377>;
      <D.20377>:
    }
    <D.21593>:
    goto <D.20378>;
    <D.20379>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.86 = (unsigned int) _index;
        D.21638 = _index.86 * 4;
        _objptr = _objptr + D.21638;
        D.21639 = _index + 1;
        _bmap = _bmap >> D.21639;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21640>; else goto <D.21641>;
          <D.21640>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21642>; else goto <D.21643>;
          <D.21642>:
          if (__old != __copy) goto <D.21644>; else goto <D.21645>;
          <D.21644>:
          gc_debug_file.83 = gc_debug_file;
          D.21646 = *_objptr;
          fprintf (gc_debug_file.83, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21646, __old);
          gc_debug_file.83 = gc_debug_file;
          fflush (gc_debug_file.83);
          <D.21645>:
          <D.21643>:
          D.21650 = sgen_ptr_in_nursery (__copy);
          if (D.21650 != 0) goto <D.21651>; else goto <D.21648>;
          <D.21651>:
          D.21652 = sgen_ptr_in_nursery (_objptr);
          if (D.21652 == 0) goto <D.21653>; else goto <D.21648>;
          <D.21653>:
          iftmp.87 = 1;
          goto <D.21649>;
          <D.21648>:
          iftmp.87 = 0;
          <D.21649>:
          D.21654 = iftmp.87 != 0;
          D.21655 = (long int) D.21654;
          D.21656 = __builtin_expect (D.21655, 0);
          if (D.21656 != 0) goto <D.21657>; else goto <D.21658>;
          <D.21657>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21658>:
          <D.21641>:
        }
        _objptr = _objptr + 4;
      }
      goto <D.20389>;
      <D.20388>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.88 = (unsigned int) _index;
        D.21660 = _index.88 * 4;
        _objptr = _objptr + D.21660;
        D.21661 = _index + 1;
        _bmap = _bmap >> D.21661;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21662>; else goto <D.21663>;
          <D.21662>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21664>; else goto <D.21665>;
          <D.21664>:
          if (__old != __copy) goto <D.21666>; else goto <D.21667>;
          <D.21666>:
          gc_debug_file.83 = gc_debug_file;
          D.21646 = *_objptr;
          fprintf (gc_debug_file.83, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21646, __old);
          gc_debug_file.83 = gc_debug_file;
          fflush (gc_debug_file.83);
          <D.21667>:
          <D.21665>:
          D.21671 = sgen_ptr_in_nursery (__copy);
          if (D.21671 != 0) goto <D.21672>; else goto <D.21669>;
          <D.21672>:
          D.21673 = sgen_ptr_in_nursery (_objptr);
          if (D.21673 == 0) goto <D.21674>; else goto <D.21669>;
          <D.21674>:
          iftmp.89 = 1;
          goto <D.21670>;
          <D.21669>:
          iftmp.89 = 0;
          <D.21670>:
          D.21675 = iftmp.89 != 0;
          D.21676 = (long int) D.21675;
          D.21677 = __builtin_expect (D.21676, 0);
          if (D.21677 != 0) goto <D.21678>; else goto <D.21679>;
          <D.21678>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21679>:
          <D.21663>:
        }
        _objptr = _objptr + 4;
      }
      <D.20389>:
      if (_bmap != 0) goto <D.20388>; else goto <D.20390>;
      <D.20390>:
    }
    goto <D.20378>;
    <D.20391>:
    D.21680 = desc & 4294950912;
    if (D.21680 != 0) goto <D.21681>; else goto <D.21682>;
    <D.21681>:
    {
      int el_size;
      int etype;

      D.21683 = desc >> 3;
      D.21684 = (int) D.21683;
      el_size = D.21684 & 1023;
      desc.90 = (int) desc;
      etype = desc.90 & 49152;
      if (etype == 16384) goto <D.21686>; else goto <D.21687>;
      <D.21686>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.21688 = MEM[(struct MonoArray *)start].max_length;
        el_size.91 = (unsigned int) el_size;
        D.21690 = D.21688 * el_size.91;
        end_refs = p + D.21690;
        goto <D.20399>;
        <D.20398>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.21691>; else goto <D.21692>;
          <D.21691>:
          split_nursery_parallel_copy_object (p, queue);
          __copy = *p;
          if (0 != 0) goto <D.21693>; else goto <D.21694>;
          <D.21693>:
          if (__old != __copy) goto <D.21695>; else goto <D.21696>;
          <D.21695>:
          gc_debug_file.83 = gc_debug_file;
          D.21697 = *p;
          fprintf (gc_debug_file.83, "Overwrote field at %p with %p (was: %p)\n", p, D.21697, __old);
          gc_debug_file.83 = gc_debug_file;
          fflush (gc_debug_file.83);
          <D.21696>:
          <D.21694>:
          D.21701 = sgen_ptr_in_nursery (__copy);
          if (D.21701 != 0) goto <D.21702>; else goto <D.21699>;
          <D.21702>:
          D.21703 = sgen_ptr_in_nursery (p);
          if (D.21703 == 0) goto <D.21704>; else goto <D.21699>;
          <D.21704>:
          iftmp.92 = 1;
          goto <D.21700>;
          <D.21699>:
          iftmp.92 = 0;
          <D.21700>:
          D.21705 = iftmp.92 != 0;
          D.21706 = (long int) D.21705;
          D.21707 = __builtin_expect (D.21706, 0);
          if (D.21707 != 0) goto <D.21708>; else goto <D.21709>;
          <D.21708>:
          sgen_add_to_global_remset (p, __copy);
          <D.21709>:
          <D.21692>:
        }
        p = p + 4;
        <D.20399>:
        if (p < end_refs) goto <D.20398>; else goto <D.20400>;
        <D.20400>:
      }
      goto <D.21710>;
      <D.21687>:
      if (etype == 32768) goto <D.21711>; else goto <D.21712>;
      <D.21711>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.21594 = desc >> 16;
        D.21713 = (int) D.21594;
        offset = D.21713 & 255;
        D.21597 = desc >> 24;
        num_refs = (int) D.21597;
        e_start = start + 16;
        D.21688 = MEM[(struct MonoArray *)start].max_length;
        el_size.91 = (unsigned int) el_size;
        D.21690 = D.21688 * el_size.91;
        e_end = e_start + D.21690;
        goto <D.20413>;
        <D.20412>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.93 = (unsigned int) offset;
          D.21715 = offset.93 * 4;
          p = p + D.21715;
          i = 0;
          goto <D.20410>;
          <D.20409>:
          {
            void * __old;
            void * __copy;

            i.94 = (unsigned int) i;
            D.21717 = i.94 * 4;
            D.21718 = p + D.21717;
            __old = *D.21718;
            if (__old != 0B) goto <D.21719>; else goto <D.21720>;
            <D.21719>:
            i.94 = (unsigned int) i;
            D.21717 = i.94 * 4;
            D.21718 = p + D.21717;
            split_nursery_parallel_copy_object (D.21718, queue);
            i.94 = (unsigned int) i;
            D.21717 = i.94 * 4;
            D.21718 = p + D.21717;
            __copy = *D.21718;
            if (0 != 0) goto <D.21721>; else goto <D.21722>;
            <D.21721>:
            if (__old != __copy) goto <D.21723>; else goto <D.21724>;
            <D.21723>:
            gc_debug_file.83 = gc_debug_file;
            i.94 = (unsigned int) i;
            D.21717 = i.94 * 4;
            D.21718 = p + D.21717;
            i.94 = (unsigned int) i;
            D.21717 = i.94 * 4;
            D.21718 = p + D.21717;
            D.21725 = *D.21718;
            fprintf (gc_debug_file.83, "Overwrote field at %p with %p (was: %p)\n", D.21718, D.21725, __old);
            gc_debug_file.83 = gc_debug_file;
            fflush (gc_debug_file.83);
            <D.21724>:
            <D.21722>:
            D.21729 = sgen_ptr_in_nursery (__copy);
            if (D.21729 != 0) goto <D.21730>; else goto <D.21727>;
            <D.21730>:
            i.94 = (unsigned int) i;
            D.21717 = i.94 * 4;
            D.21731 = p + D.21717;
            D.21732 = sgen_ptr_in_nursery (D.21731);
            if (D.21732 == 0) goto <D.21733>; else goto <D.21727>;
            <D.21733>:
            iftmp.95 = 1;
            goto <D.21728>;
            <D.21727>:
            iftmp.95 = 0;
            <D.21728>:
            D.21734 = iftmp.95 != 0;
            D.21735 = (long int) D.21734;
            D.21736 = __builtin_expect (D.21735, 0);
            if (D.21736 != 0) goto <D.21737>; else goto <D.21738>;
            <D.21737>:
            i.94 = (unsigned int) i;
            D.21717 = i.94 * 4;
            D.21739 = p + D.21717;
            sgen_add_to_global_remset (D.21739, __copy);
            <D.21738>:
            <D.21720>:
          }
          i = i + 1;
          <D.20410>:
          if (i < num_refs) goto <D.20409>; else goto <D.20411>;
          <D.20411>:
          el_size.96 = (sizetype) el_size;
          e_start = e_start + el_size.96;
        }
        <D.20413>:
        if (e_start < e_end) goto <D.20412>; else goto <D.20414>;
        <D.20414>:
      }
      goto <D.21741>;
      <D.21712>:
      if (etype == 49152) goto <D.21742>; else goto <D.21743>;
      <D.21742>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.21688 = MEM[(struct MonoArray *)start].max_length;
        el_size.91 = (unsigned int) el_size;
        D.21690 = D.21688 * el_size.91;
        e_end = e_start + D.21690;
        goto <D.20425>;
        <D.20424>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.20422>;
          <D.20421>:
          D.21744 = _bmap & 1;
          if (D.21744 != 0) goto <D.21745>; else goto <D.21746>;
          <D.21745>:
          {
            void * __old;
            void * __copy;

            __old = *p;
            if (__old != 0B) goto <D.21747>; else goto <D.21748>;
            <D.21747>:
            split_nursery_parallel_copy_object (p, queue);
            __copy = *p;
            if (0 != 0) goto <D.21749>; else goto <D.21750>;
            <D.21749>:
            if (__old != __copy) goto <D.21751>; else goto <D.21752>;
            <D.21751>:
            gc_debug_file.83 = gc_debug_file;
            D.21753 = *p;
            fprintf (gc_debug_file.83, "Overwrote field at %p with %p (was: %p)\n", p, D.21753, __old);
            gc_debug_file.83 = gc_debug_file;
            fflush (gc_debug_file.83);
            <D.21752>:
            <D.21750>:
            D.21757 = sgen_ptr_in_nursery (__copy);
            if (D.21757 != 0) goto <D.21758>; else goto <D.21755>;
            <D.21758>:
            D.21759 = sgen_ptr_in_nursery (p);
            if (D.21759 == 0) goto <D.21760>; else goto <D.21755>;
            <D.21760>:
            iftmp.97 = 1;
            goto <D.21756>;
            <D.21755>:
            iftmp.97 = 0;
            <D.21756>:
            D.21761 = iftmp.97 != 0;
            D.21762 = (long int) D.21761;
            D.21763 = __builtin_expect (D.21762, 0);
            if (D.21763 != 0) goto <D.21764>; else goto <D.21765>;
            <D.21764>:
            sgen_add_to_global_remset (p, __copy);
            <D.21765>:
            <D.21748>:
          }
          <D.21746>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.20422>:
          if (_bmap != 0) goto <D.20421>; else goto <D.20423>;
          <D.20423>:
          el_size.96 = (sizetype) el_size;
          e_start = e_start + el_size.96;
        }
        <D.20425>:
        if (e_start < e_end) goto <D.20424>; else goto <D.20426>;
        <D.20426>:
      }
      <D.21743>:
      <D.21741>:
      <D.21710>:
    }
    <D.21682>:
    goto <D.20378>;
    <D.20427>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.20433>;
      <D.20432>:
      D.21766 = _bmap & 1;
      if (D.21766 != 0) goto <D.21767>; else goto <D.21768>;
      <D.21767>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21769>; else goto <D.21770>;
        <D.21769>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21771>; else goto <D.21772>;
        <D.21771>:
        if (__old != __copy) goto <D.21773>; else goto <D.21774>;
        <D.21773>:
        gc_debug_file.83 = gc_debug_file;
        D.21775 = *_objptr;
        fprintf (gc_debug_file.83, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21775, __old);
        gc_debug_file.83 = gc_debug_file;
        fflush (gc_debug_file.83);
        <D.21774>:
        <D.21772>:
        D.21779 = sgen_ptr_in_nursery (__copy);
        if (D.21779 != 0) goto <D.21780>; else goto <D.21777>;
        <D.21780>:
        D.21781 = sgen_ptr_in_nursery (_objptr);
        if (D.21781 == 0) goto <D.21782>; else goto <D.21777>;
        <D.21782>:
        iftmp.98 = 1;
        goto <D.21778>;
        <D.21777>:
        iftmp.98 = 0;
        <D.21778>:
        D.21783 = iftmp.98 != 0;
        D.21784 = (long int) D.21783;
        D.21785 = __builtin_expect (D.21784, 0);
        if (D.21785 != 0) goto <D.21786>; else goto <D.21787>;
        <D.21786>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21787>:
        <D.21770>:
      }
      <D.21768>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20433>:
      if (_bmap != 0) goto <D.20432>; else goto <D.20434>;
      <D.20434>:
    }
    goto <D.20378>;
    <D.20435>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.21788 = *bitmap_data;
      D.21789 = D.21788 + 4294967295;
      bwords = (int) D.21789;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.21790>; else goto <D.21791>;
      <D.21790>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.21792 = myobj->vtable;
        D.21793 = D.21792->klass;
        D.21794 = D.21793->name_space;
        D.21792 = myobj->vtable;
        D.21793 = D.21792->klass;
        D.21795 = D.21793->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21794, D.21795);
      }
      <D.21791>:
      goto <D.20448>;
      <D.20447>:
      {
        gsize _bmap;

        bitmap_data.99 = bitmap_data;
        bitmap_data = bitmap_data.99 + 4;
        _bmap = *bitmap_data.99;
        _objptr = start_run;
        goto <D.20445>;
        <D.20444>:
        D.21797 = _bmap & 1;
        if (D.21797 != 0) goto <D.21798>; else goto <D.21799>;
        <D.21798>:
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21800>; else goto <D.21801>;
          <D.21800>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21802>; else goto <D.21803>;
          <D.21802>:
          if (__old != __copy) goto <D.21804>; else goto <D.21805>;
          <D.21804>:
          gc_debug_file.83 = gc_debug_file;
          D.21806 = *_objptr;
          fprintf (gc_debug_file.83, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21806, __old);
          gc_debug_file.83 = gc_debug_file;
          fflush (gc_debug_file.83);
          <D.21805>:
          <D.21803>:
          D.21810 = sgen_ptr_in_nursery (__copy);
          if (D.21810 != 0) goto <D.21811>; else goto <D.21808>;
          <D.21811>:
          D.21812 = sgen_ptr_in_nursery (_objptr);
          if (D.21812 == 0) goto <D.21813>; else goto <D.21808>;
          <D.21813>:
          iftmp.100 = 1;
          goto <D.21809>;
          <D.21808>:
          iftmp.100 = 0;
          <D.21809>:
          D.21814 = iftmp.100 != 0;
          D.21815 = (long int) D.21814;
          D.21816 = __builtin_expect (D.21815, 0);
          if (D.21816 != 0) goto <D.21817>; else goto <D.21818>;
          <D.21817>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21818>:
          <D.21801>:
        }
        <D.21799>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.20445>:
        if (_bmap != 0) goto <D.20444>; else goto <D.20446>;
        <D.20446>:
        start_run = start_run + 128;
      }
      <D.20448>:
      bwords.101 = bwords;
      bwords = bwords.101 + -1;
      if (bwords.101 > 0) goto <D.20447>; else goto <D.20449>;
      <D.20449>:
    }
    goto <D.20378>;
    <D.20450>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.21820 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.21820);
      mbitmap_data.102 = mbitmap_data;
      mbitmap_data = mbitmap_data.102 + 4;
      D.21822 = *mbitmap_data.102;
      D.21823 = D.21822 + 4294967295;
      mbwords = (int) D.21823;
      D.21824 = vt->klass;
      el_size = mono_array_element_size (D.21824);
      e_start = start + 16;
      D.21688 = MEM[(struct MonoArray *)start].max_length;
      el_size.103 = (unsigned int) el_size;
      D.21826 = D.21688 * el_size.103;
      e_end = e_start + D.21826;
      if (0 != 0) goto <D.21827>; else goto <D.21828>;
      <D.21827>:
      D.21820 = vt->desc;
      D.21824 = vt->klass;
      D.21829 = D.21824->name_space;
      D.21824 = vt->klass;
      D.21830 = D.21824->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.21820, D.21829, D.21830);
      <D.21828>:
      goto <D.20470>;
      <D.20469>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.104 = bitmap_data;
          bitmap_data = bitmap_data.104 + 4;
          _bmap = *bitmap_data.104;
          start_run = _objptr;
          goto <D.20464>;
          <D.20463>:
          D.21832 = _bmap & 1;
          if (D.21832 != 0) goto <D.21833>; else goto <D.21834>;
          <D.21833>:
          {
            void * __old;
            void * __copy;

            __old = *_objptr;
            if (__old != 0B) goto <D.21835>; else goto <D.21836>;
            <D.21835>:
            split_nursery_parallel_copy_object (_objptr, queue);
            __copy = *_objptr;
            if (0 != 0) goto <D.21837>; else goto <D.21838>;
            <D.21837>:
            if (__old != __copy) goto <D.21839>; else goto <D.21840>;
            <D.21839>:
            gc_debug_file.83 = gc_debug_file;
            D.21841 = *_objptr;
            fprintf (gc_debug_file.83, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21841, __old);
            gc_debug_file.83 = gc_debug_file;
            fflush (gc_debug_file.83);
            <D.21840>:
            <D.21838>:
            D.21845 = sgen_ptr_in_nursery (__copy);
            if (D.21845 != 0) goto <D.21846>; else goto <D.21843>;
            <D.21846>:
            D.21847 = sgen_ptr_in_nursery (_objptr);
            if (D.21847 == 0) goto <D.21848>; else goto <D.21843>;
            <D.21848>:
            iftmp.105 = 1;
            goto <D.21844>;
            <D.21843>:
            iftmp.105 = 0;
            <D.21844>:
            D.21849 = iftmp.105 != 0;
            D.21850 = (long int) D.21849;
            D.21851 = __builtin_expect (D.21850, 0);
            if (D.21851 != 0) goto <D.21852>; else goto <D.21853>;
            <D.21852>:
            sgen_add_to_global_remset (_objptr, __copy);
            <D.21853>:
            <D.21836>:
          }
          <D.21834>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.20464>:
          if (_bmap != 0) goto <D.20463>; else goto <D.20465>;
          <D.20465>:
          _objptr = start_run + 128;
        }
        <D.20467>:
        bwords.106 = bwords;
        bwords = bwords.106 + 4294967295;
        if (bwords.106 != 0) goto <D.20466>; else goto <D.20468>;
        <D.20468>:
        el_size.107 = (sizetype) el_size;
        e_start = e_start + el_size.107;
      }
      <D.20470>:
      if (e_start < e_end) goto <D.20469>; else goto <D.20471>;
      <D.20471>:
    }
    goto <D.20378>;
    <D.20472>:
    goto <D.20378>;
    <D.20473>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.20378>:
  }
}


split_nursery_parallel_copy_object (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.108;
  int D.21860;
  unsigned int D.21863;
  unsigned int D.21864;
  unsigned int D.21867;
  int D.21870;
  unsigned int D.21873;
  unsigned int D.21874;
  void * D.21875;
  unsigned int D.21876;
  _Bool D.21877;
  long int D.21878;
  long int D.21879;
  unsigned int destination.109;
  unsigned int D.21883;
  void * D.21884;
  void * D.21885;
  struct SgenGrayQueue * iftmp.110;
  int D.21893;
  _Bool D.21897;
  long int D.21898;
  long int D.21899;
  char * obj;
  mword vtable_word;
  mword objsize;
  struct MonoVTable * vt;
  void * destination;
  gboolean has_references;

  obj = *obj_slot;
  if (0 != 0) goto <D.21857>; else goto <D.21858>;
  <D.21857>:
  current_collection_generation.108 = current_collection_generation;
  monoeg_g_log (0B, 4, "calling minor-par-copy from a %d generation collection", current_collection_generation.108);
  <D.20360>:
  goto <D.20360>;
  <D.21858>:
  D.21860 = sgen_ptr_in_nursery (obj);
  if (D.21860 == 0) goto <D.21861>; else goto <D.21862>;
  <D.21861>:
  return;
  <D.21862>:
  vtable_word = MEM[(mword *)obj];
  D.21863 = vtable_word & 4294967292;
  vt = (struct MonoVTable *) D.21863;
  D.21864 = vtable_word & 1;
  if (D.21864 != 0) goto <D.21865>; else goto <D.21866>;
  <D.21865>:
  *obj_slot = vt;
  return;
  <D.21866>:
  D.21867 = vtable_word & 2;
  if (D.21867 != 0) goto <D.21868>; else goto <D.21869>;
  <D.21868>:
  return;
  <D.21869>:
  D.21870 = sgen_nursery_is_to_space (obj);
  if (D.21870 != 0) goto <D.21871>; else goto <D.21872>;
  <D.21871>:
  return;
  <D.21872>:
  D.21873 = sgen_par_object_get_size (vt, obj);
  D.21874 = D.21873 + 7;
  objsize = D.21874 & 4294967288;
  D.21875 = vt->gc_descr;
  D.21876 = (unsigned int) D.21875;
  has_references = sgen_gc_descr_has_references (D.21876);
  destination = par_alloc_for_promotion (vt, obj, objsize, has_references);
  D.21877 = destination == 0B;
  D.21878 = (long int) D.21877;
  D.21879 = __builtin_expect (D.21878, 0);
  if (D.21879 != 0) goto <D.21880>; else goto <D.21881>;
  <D.21880>:
  sgen_parallel_pin_or_update (obj_slot, obj, vt, queue);
  return;
  <D.21881>:
  MEM[(struct MonoVTable * *)destination] = vt;
  destination.109 = (unsigned int) destination;
  D.21883 = destination.109 | 1;
  D.21884 = (void *) D.21883;
  D.21885 = InterlockedCompareExchangePointer (obj, D.21884, vt);
  if (D.21885 == vt) goto <D.21886>; else goto <D.21887>;
  <D.21886>:
  if (has_references != 0) goto <D.21889>; else goto <D.21890>;
  <D.21889>:
  iftmp.110 = queue;
  goto <D.21891>;
  <D.21890>:
  iftmp.110 = 0B;
  <D.21891>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.110);
  obj = destination;
  *obj_slot = obj;
  goto <D.21892>;
  <D.21887>:
  D.21893 = sgen_ptr_in_nursery (destination);
  if (D.21893 == 0) goto <D.21894>; else goto <D.21895>;
  <D.21894>:
  MEM[(void * *)destination] = 0B;
  goto <D.21896>;
  <D.21895>:
  memset (destination, 0, objsize);
  <D.21896>:
  vtable_word = MEM[(mword *)obj];
  D.21864 = vtable_word & 1;
  D.21897 = D.21864 == 0;
  D.21898 = (long int) D.21897;
  D.21899 = __builtin_expect (D.21898, 0);
  if (D.21899 != 0) goto <D.21900>; else goto <D.21901>;
  <D.21900>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-minor-copy-object.h", 291, "vtable_word & SGEN_FORWARDED_BIT");
  <D.21901>:
  D.21863 = vtable_word & 4294967292;
  obj = (char *) D.21863;
  *obj_slot = obj;
  <D.21892>:
}


par_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int promote_age.111;
  char * D.21906;
  void * (*<T3846>) (struct MonoVTable *, int, gboolean) D.21907;
  int objsize.112;
  char * D.21909;
  char * D.21910;
  _Bool D.21911;
  long int D.21912;
  long int D.21913;
  char * * D.21916;
  void * D.21917;
  void * D.21918;
  char * p;
  int age;
  void restart = <<< error >>>;

  age = get_object_age (obj);
  promote_age.111 = promote_age;
  if (age >= promote_age.111) goto <D.21904>; else goto <D.21905>;
  <D.21904>:
  D.21907 = major_collector.par_alloc_object;
  objsize.112 = (int) objsize;
  D.21906 = D.21907 (vtable, objsize.112, has_references);
  return D.21906;
  <D.21905>:
  restart:
  p = age_alloc_buffers[age].next;
  mono_memory_read_barrier ();
  D.21909 = p + objsize;
  D.21910 = age_alloc_buffers[age].end;
  D.21911 = D.21909 <= D.21910;
  D.21912 = (long int) D.21911;
  D.21913 = __builtin_expect (D.21912, 1);
  if (D.21913 != 0) goto <D.21914>; else goto <D.21915>;
  <D.21914>:
  D.21916 = &age_alloc_buffers[age].next;
  D.21917 = p + objsize;
  D.21918 = InterlockedCompareExchangePointer (D.21916, D.21917, p);
  if (D.21918 != p) goto restart; else goto <D.21919>;
  <D.21919>:
  goto <D.21920>;
  <D.21915>:
  p = par_alloc_for_promotion_slow_path (age, objsize);
  if (p == 0B) goto <D.21921>; else goto <D.21922>;
  <D.21921>:
  D.21907 = major_collector.par_alloc_object;
  objsize.112 = (int) objsize;
  D.21906 = D.21907 (vtable, objsize.112, has_references);
  return D.21906;
  <D.21922>:
  <D.21920>:
  MEM[(struct MonoVTable * *)p] = vtable;
  D.21906 = p;
  return D.21906;
}


mono_memory_read_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


par_alloc_for_promotion_slow_path (int age, size_t objsize)
{
  unsigned int D.21924;
  char * D.21925;
  char * D.21926;
  _Bool D.21927;
  long int D.21928;
  long int D.21929;
  char * * D.21932;
  void * D.21933;
  void * D.21934;
  void * D.21939;
  unsigned int D.21940;
  unsigned int D.21941;
  unsigned int allocated_size.113;
  char * D.21945;
  char * D.21946;
  char * p;
  size_t allocated_size;
  size_t aligned_objsize;
  void restart = <<< error >>>;

  try
    {
      D.21924 = objsize + 511;
      aligned_objsize = D.21924 & 4294966784;
      pthread_mutex_lock (&par_alloc_buffer_refill_mutex);
      restart:
      p = age_alloc_buffers[age].next;
      D.21925 = p + objsize;
      D.21926 = age_alloc_buffers[age].end;
      D.21927 = D.21925 <= D.21926;
      D.21928 = (long int) D.21927;
      D.21929 = __builtin_expect (D.21928, 1);
      if (D.21929 != 0) goto <D.21930>; else goto <D.21931>;
      <D.21930>:
      D.21932 = &age_alloc_buffers[age].next;
      D.21933 = p + objsize;
      D.21934 = InterlockedCompareExchangePointer (D.21932, D.21933, p);
      if (D.21934 != p) goto restart; else goto <D.21935>;
      <D.21935>:
      goto <D.21936>;
      <D.21931>:
      {
        char * end;

        end = age_alloc_buffers[age].end;
        if (end != 0B) goto <D.21937>; else goto <D.21938>;
        <D.21937>:
        <D.20227>:
        p = age_alloc_buffers[age].next;
        D.21932 = &age_alloc_buffers[age].next;
        D.21939 = InterlockedCompareExchangePointer (D.21932, end, p);
        if (D.21939 != p) goto <D.20227>; else goto <D.20228>;
        <D.20228>:
        sgen_clear_range (p, end);
        <D.21938>:
        age_alloc_buffers[age].end = 0B;
        mono_memory_write_barrier ();
        D.21940 = MAX_EXPR <aligned_objsize, 4096>;
        D.21941 = MAX_EXPR <aligned_objsize, 512>;
        p = sgen_fragment_allocator_par_range_alloc (&collector_allocator, D.21940, D.21941, &allocated_size);
        if (p != 0B) goto <D.21942>; else goto <D.21943>;
        <D.21942>:
        allocated_size.113 = allocated_size;
        D.21945 = p + allocated_size.113;
        set_age_in_range (p, D.21945, age);
        D.21925 = p + objsize;
        age_alloc_buffers[age].next = D.21925;
        mono_memory_write_barrier ();
        allocated_size.113 = allocated_size;
        D.21945 = p + allocated_size.113;
        age_alloc_buffers[age].end = D.21945;
        <D.21943>:
      }
      <D.21936>:
      pthread_mutex_unlock (&par_alloc_buffer_refill_mutex);
      D.21946 = p;
      return D.21946;
    }
  finally
    {
      allocated_size = {CLOBBER};
    }
}


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.21949;
  unsigned int comp.114;
  unsigned int exch.115;
  unsigned int D.21952;

  comp.114 = (unsigned int) comp;
  exch.115 = (unsigned int) exch;
  D.21952 = __sync_val_compare_and_swap_4 (dest, comp.114, exch.115);
  D.21949 = (void *) D.21952;
  return D.21949;
}


split_nursery_serial_copy_object (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.116;
  int D.21957;
  struct FILE * gc_debug_file.117;
  char * iftmp.118;
  unsigned int D.21964;
  unsigned int D.21965;
  unsigned int D.21968;
  unsigned int D.21976;
  _Bool D.21977;
  long int D.21978;
  long int D.21979;
  int D.21986;
  void * D.21993;
  char * forwarded;
  char * obj;

  obj = *obj_slot;
  if (0 != 0) goto <D.21954>; else goto <D.21955>;
  <D.21954>:
  current_collection_generation.116 = current_collection_generation;
  monoeg_g_log (0B, 4, "calling minor-serial-copy from a %d generation collection", current_collection_generation.116);
  <D.20335>:
  goto <D.20335>;
  <D.21955>:
  D.21957 = sgen_ptr_in_nursery (obj);
  if (D.21957 == 0) goto <D.21958>; else goto <D.21959>;
  <D.21958>:
  return;
  <D.21959>:
  if (0 != 0) goto <D.21960>; else goto <D.21961>;
  <D.21960>:
  gc_debug_file.117 = gc_debug_file;
  fprintf (gc_debug_file.117, "Precise copy of %p from %p\n", obj, obj_slot);
  gc_debug_file.117 = gc_debug_file;
  fflush (gc_debug_file.117);
  <D.21961>:
  D.21964 = MEM[(mword *)obj];
  D.21965 = D.21964 & 1;
  if (D.21965 != 0) goto <D.21966>; else goto <D.21967>;
  <D.21966>:
  D.21964 = MEM[(mword *)obj];
  D.21968 = D.21964 & 4294967292;
  iftmp.118 = (char *) D.21968;
  goto <D.21969>;
  <D.21967>:
  iftmp.118 = 0B;
  <D.21969>:
  forwarded = iftmp.118;
  if (forwarded != 0B) goto <D.21970>; else goto <D.21971>;
  <D.21970>:
  if (0 != 0) goto <D.21972>; else goto <D.21973>;
  <D.21972>:
  monoeg_g_log (0B, 4, "forwarded object %p has no gc descriptor", forwarded);
  <D.20336>:
  goto <D.20336>;
  <D.21973>:
  if (0 != 0) goto <D.21974>; else goto <D.21975>;
  <D.21974>:
  gc_debug_file.117 = gc_debug_file;
  fprintf (gc_debug_file.117, " (already forwarded to %p)\n", forwarded);
  gc_debug_file.117 = gc_debug_file;
  fflush (gc_debug_file.117);
  <D.21975>:
  *obj_slot = forwarded;
  return;
  <D.21971>:
  D.21964 = MEM[(mword *)obj];
  D.21976 = D.21964 & 2;
  D.21977 = D.21976 != 0;
  D.21978 = (long int) D.21977;
  D.21979 = __builtin_expect (D.21978, 0);
  if (D.21979 != 0) goto <D.21980>; else goto <D.21981>;
  <D.21980>:
  if (0 != 0) goto <D.21982>; else goto <D.21983>;
  <D.21982>:
  monoeg_g_log (0B, 4, "pinned object %p has no gc descriptor", obj);
  <D.20337>:
  goto <D.20337>;
  <D.21983>:
  if (0 != 0) goto <D.21984>; else goto <D.21985>;
  <D.21984>:
  gc_debug_file.117 = gc_debug_file;
  fprintf (gc_debug_file.117, " (pinned, no change)\n");
  gc_debug_file.117 = gc_debug_file;
  fflush (gc_debug_file.117);
  <D.21985>:
  return;
  <D.21981>:
  D.21986 = sgen_nursery_is_to_space (obj);
  if (D.21986 != 0) goto <D.21987>; else goto <D.21988>;
  <D.21987>:
  if (0 != 0) goto <D.21989>; else goto <D.21990>;
  <D.21989>:
  monoeg_g_log (0B, 4, "to space object %p has no gc descriptor", obj);
  <D.20338>:
  goto <D.20338>;
  <D.21990>:
  if (0 != 0) goto <D.21991>; else goto <D.21992>;
  <D.21991>:
  gc_debug_file.117 = gc_debug_file;
  fprintf (gc_debug_file.117, " (tospace, no change)\n");
  gc_debug_file.117 = gc_debug_file;
  fflush (gc_debug_file.117);
  <D.21992>:
  return;
  <D.21988>:
  D.21993 = copy_object_no_checks (obj, queue);
  *obj_slot = D.21993;
}


print_gc_param_usage ()
{
  struct _IO_FILE * stderr.119;

  stderr.119 = stderr;
  fprintf (stderr.119, "  alloc-ratio=P (where P is a percentage, an integer in 1-100)\n  promotion-age=P (where P is a number, an integer in 1-%d)\n", 14);
}


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

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


handle_gc_param (const char * opt)
{
  int D.21998;
  char * D.22001;
  unsigned int percentage.120;
  unsigned int D.22003;
  struct _IO_FILE * stderr.121;
  float D.22007;
  float alloc_ratio.122;
  gboolean D.22009;
  int D.22010;
  char * D.22013;
  int promote_age.123;
  int promote_age.124;
  unsigned int promote_age.125;
  unsigned int D.22017;

  D.21998 = monoeg_g_str_has_prefix (opt, "alloc-ratio=");
  if (D.21998 != 0) goto <D.21999>; else goto <D.22000>;
  <D.21999>:
  {
    const char * arg;
    int percentage;

    D.22001 = __builtin_strchr (opt, 61);
    arg = D.22001 + 1;
    percentage = atoi (arg);
    percentage.120 = (unsigned int) percentage;
    D.22003 = percentage.120 + 4294967295;
    if (D.22003 > 99) goto <D.22004>; else goto <D.22005>;
    <D.22004>:
    stderr.121 = stderr;
    fprintf (stderr.121, "alloc-ratio must be an integer in the range 1-100.\n");
    exit (1);
    <D.22005>:
    D.22007 = (float) percentage;
    alloc_ratio.122 = D.22007 / 1.0e+2;
    alloc_ratio = alloc_ratio.122;
    D.22009 = 1;
    return D.22009;
  }
  <D.22000>:
  D.22010 = monoeg_g_str_has_prefix (opt, "promotion-age=");
  if (D.22010 != 0) goto <D.22011>; else goto <D.22012>;
  <D.22011>:
  {
    const char * arg;

    D.22013 = __builtin_strchr (opt, 61);
    arg = D.22013 + 1;
    promote_age.123 = atoi (arg);
    promote_age = promote_age.123;
    promote_age.124 = promote_age;
    promote_age.125 = (unsigned int) promote_age.124;
    D.22017 = promote_age.125 + 4294967295;
    if (D.22017 > 13) goto <D.22018>; else goto <D.22019>;
    <D.22018>:
    stderr.121 = stderr;
    fprintf (stderr.121, "promotion-age must be an integer in the range 1-%d.\n", 14);
    exit (1);
    <D.22019>:
    D.22009 = 1;
    return D.22009;
  }
  <D.22012>:
  D.22009 = 0;
  return D.22009;
}


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

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


init_nursery (struct SgenFragmentAllocator * allocator, char * start, char * end)
{
  int end.126;
  int start.127;
  int D.22025;
  float D.22026;
  float alloc_ratio.128;
  float D.22028;
  unsigned int start.129;
  unsigned int alloc_quote.130;
  unsigned int D.22031;
  unsigned int D.22032;
  char * promotion_barrier.131;
  char * promotion_barrier.132;
  int region_age_size.133;
  int region_age_size.134;
  unsigned int region_age_size.135;
  void * region_age.136;
  int alloc_quote;

  end.126 = (int) end;
  start.127 = (int) start;
  D.22025 = end.126 - start.127;
  D.22026 = (float) D.22025;
  alloc_ratio.128 = alloc_ratio;
  D.22028 = D.22026 * alloc_ratio.128;
  alloc_quote = (int) D.22028;
  start.129 = (unsigned int) start;
  alloc_quote.130 = (unsigned int) alloc_quote;
  D.22031 = start.129 + alloc_quote.130;
  D.22032 = D.22031 & 4294967288;
  promotion_barrier.131 = (char *) D.22032;
  promotion_barrier = promotion_barrier.131;
  promotion_barrier.132 = promotion_barrier;
  sgen_fragment_allocator_add (allocator, start, promotion_barrier.132);
  promotion_barrier.132 = promotion_barrier;
  sgen_fragment_allocator_add (&collector_allocator, promotion_barrier.132, end);
  end.126 = (int) end;
  start.127 = (int) start;
  D.22025 = end.126 - start.127;
  region_age_size.133 = D.22025 >> 9;
  region_age_size = region_age_size.133;
  region_age_size.134 = region_age_size;
  region_age_size.135 = (unsigned int) region_age_size.134;
  region_age.136 = monoeg_malloc0 (region_age_size.135);
  region_age = region_age.136;
}


build_fragments_finish (struct SgenFragmentAllocator * allocator)
{
  collector_allocator = *allocator;
  fragment_list_split (&collector_allocator);
}


fragment_list_split (struct SgenFragmentAllocator * allocator)
{
  char * D.22039;
  char * promotion_barrier.137;
  char * D.22043;
  struct SgenFragment * D.22046;
  struct SgenFragment * D.22047;
  char * D.22048;
  char * D.22049;
  _Bool D.22050;
  long int D.22051;
  long int D.22052;
  struct SgenFragment * D.22055;
  struct SgenFragment * D.22058;
  struct SgenFragment * prev;
  struct SgenFragment * list;

  prev = 0B;
  list = allocator->region_head;
  goto <D.20201>;
  <D.20200>:
  D.22039 = list->fragment_end;
  promotion_barrier.137 = promotion_barrier;
  if (D.22039 > promotion_barrier.137) goto <D.22041>; else goto <D.22042>;
  <D.22041>:
  D.22043 = list->fragment_start;
  promotion_barrier.137 = promotion_barrier;
  if (D.22043 < promotion_barrier.137) goto <D.22044>; else goto <D.22045>;
  <D.22044>:
  {
    struct SgenFragment * res;

    res = sgen_fragment_allocator_alloc ();
    promotion_barrier.137 = promotion_barrier;
    res->fragment_start = promotion_barrier.137;
    promotion_barrier.137 = promotion_barrier;
    res->fragment_next = promotion_barrier.137;
    D.22039 = list->fragment_end;
    res->fragment_end = D.22039;
    D.22046 = list->next;
    res->next = D.22046;
    D.22047 = list->next_in_order;
    res->next_in_order = D.22047;
    D.22048 = res->fragment_end;
    D.22049 = res->fragment_start;
    D.22050 = D.22048 <= D.22049;
    D.22051 = (long int) D.22050;
    D.22052 = __builtin_expect (D.22051, 0);
    if (D.22052 != 0) goto <D.22053>; else goto <D.22054>;
    <D.22053>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-split-nursery.c", 220, "res->fragment_end > res->fragment_start");
    <D.22054>:
    promotion_barrier.137 = promotion_barrier;
    list->fragment_end = promotion_barrier.137;
    list->next_in_order = 0B;
    D.22047 = list->next_in_order;
    list->next = D.22047;
    D.22043 = list->fragment_start;
    D.22039 = list->fragment_end;
    set_age_in_range (D.22043, D.22039, 0);
    allocator->alloc_head = res;
    D.22055 = allocator->alloc_head;
    allocator->region_head = D.22055;
    return;
  }
  <D.22045>:
  if (prev != 0B) goto <D.22056>; else goto <D.22057>;
  <D.22056>:
  prev->next_in_order = 0B;
  D.22058 = prev->next_in_order;
  prev->next = D.22058;
  <D.22057>:
  allocator->alloc_head = list;
  D.22055 = allocator->alloc_head;
  allocator->region_head = D.22055;
  return;
  <D.22042>:
  D.22043 = list->fragment_start;
  D.22039 = list->fragment_end;
  set_age_in_range (D.22043, D.22039, 0);
  prev = list;
  list = list->next;
  <D.20201>:
  if (list != 0B) goto <D.20200>; else goto <D.20202>;
  <D.20202>:
  allocator->alloc_head = 0B;
  D.22055 = allocator->alloc_head;
  allocator->region_head = D.22055;
}


build_fragments_release_exclude_head ()
{
  sgen_fragment_allocator_release (&collector_allocator);
}


build_fragments_get_exclude_head ()
{
  char * D.22060;
  char * D.22063;
  struct SgenFragment * D.22064;
  int i;

  i = 0;
  goto <D.20255>;
  <D.20254>:
  D.22060 = age_alloc_buffers[i].end;
  if (D.22060 != 0B) goto <D.22061>; else goto <D.22062>;
  <D.22061>:
  D.22063 = age_alloc_buffers[i].next;
  D.22060 = age_alloc_buffers[i].end;
  sgen_clear_range (D.22063, D.22060);
  <D.22062>:
  i = i + 1;
  <D.20255>:
  if (i <= 14) goto <D.20254>; else goto <D.20256>;
  <D.20256>:
  D.22064 = collector_allocator.region_head;
  return D.22064;
}


clear_fragments ()
{
  sgen_clear_allocator_fragments (&collector_allocator);
}


prepare_to_space (char * to_space_bitmap, int space_bitmap_size)
{
  unsigned int space_bitmap_size.138;
  char * D.22067;
  unsigned int D.22068;
  unsigned int D.22069;
  unsigned int D.22070;
  char * D.22071;
  unsigned int D.22072;
  unsigned int D.22073;
  int end.139;
  int start.140;
  int D.22076;
  char * D.22079;
  struct SgenFragment * D.22080;
  struct SgenFragment * * previous;
  struct SgenFragment * frag;

  space_bitmap_size.138 = (unsigned int) space_bitmap_size;
  memset (to_space_bitmap, 0, space_bitmap_size.138);
  memset (&age_alloc_buffers, 0, 120);
  previous = &collector_allocator.alloc_head;
  frag = *previous;
  goto <D.20273>;
  <D.20272>:
  {
    char * start;
    char * end;

    D.22067 = frag->fragment_next;
    D.22068 = (unsigned int) D.22067;
    D.22069 = D.22068 + 511;
    D.22070 = D.22069 & 4294966784;
    start = (char *) D.22070;
    D.22071 = frag->fragment_end;
    D.22072 = (unsigned int) D.22071;
    D.22073 = D.22072 & 4294966784;
    end = (char *) D.22073;
    end.139 = (int) end;
    start.140 = (int) start;
    D.22076 = end.139 - start.140;
    if (D.22076 <= 511) goto <D.22077>; else goto <D.22078>;
    <D.22077>:
    D.22067 = frag->fragment_next;
    D.22071 = frag->fragment_end;
    sgen_clear_range (D.22067, D.22071);
    D.22079 = frag->fragment_start;
    frag->fragment_end = D.22079;
    D.22071 = frag->fragment_end;
    frag->fragment_next = D.22071;
    D.22080 = frag->next;
    *previous = D.22080;
    // predicted unlikely by continue predictor.
    goto <D.20271>;
    <D.22078>:
    sgen_clear_range (start, end);
    D.22067 = frag->fragment_next;
    if (D.22067 != start) goto <D.22081>; else goto <D.22082>;
    <D.22081>:
    D.22067 = frag->fragment_next;
    sgen_clear_range (D.22067, start);
    <D.22082>:
    D.22071 = frag->fragment_end;
    if (D.22071 != end) goto <D.22083>; else goto <D.22084>;
    <D.22083>:
    D.22071 = frag->fragment_end;
    sgen_clear_range (end, D.22071);
    <D.22084>:
    frag->fragment_next = start;
    D.22067 = frag->fragment_next;
    frag->fragment_start = D.22067;
    frag->fragment_end = end;
    mark_bits_in_range (to_space_bitmap, start, end);
    previous = &frag->next;
  }
  <D.20271>:
  frag = *previous;
  <D.20273>:
  if (frag != 0B) goto <D.20272>; else goto <D.20274>;
  <D.20274>:
}


mark_bits_in_range (char * space_bitmap, char * start, char * end)
{
  unsigned int start.141;
  unsigned int D.22086;
  unsigned int end.142;
  unsigned int D.22088;
  unsigned int D.22089;

  start.141 = (unsigned int) start;
  D.22086 = start.141 & 4294966784;
  start = (char *) D.22086;
  end.142 = (unsigned int) end;
  D.22088 = end.142 + 511;
  D.22089 = D.22088 & 4294966784;
  end = (char *) D.22089;
  goto <D.20192>;
  <D.20191>:
  mark_bit (space_bitmap, start);
  start = start + 512;
  <D.20192>:
  if (start < end) goto <D.20191>; else goto <D.20193>;
  <D.20193>:
}


mark_bit (char * space_bitmap, char * pos)
{
  int pos.143;
  char * sgen_nursery_start.144;
  int sgen_nursery_start.145;
  int D.22093;
  int sgen_space_bitmap_size.146;
  _Bool D.22095;
  long int D.22096;
  long int D.22097;
  sizetype byte.147;
  char * D.22101;
  char D.22102;
  signed char D.22103;
  int D.22104;
  signed char D.22105;
  signed char D.22106;
  char D.22107;
  int idx;
  int byte;
  int bit;

  pos.143 = (int) pos;
  sgen_nursery_start.144 = sgen_nursery_start;
  sgen_nursery_start.145 = (int) sgen_nursery_start.144;
  D.22093 = pos.143 - sgen_nursery_start.145;
  idx = D.22093 >> 9;
  byte = idx / 8;
  bit = idx & 7;
  sgen_space_bitmap_size.146 = sgen_space_bitmap_size;
  D.22095 = byte >= sgen_space_bitmap_size.146;
  D.22096 = (long int) D.22095;
  D.22097 = __builtin_expect (D.22096, 0);
  if (D.22097 != 0) goto <D.22098>; else goto <D.22099>;
  <D.22098>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-split-nursery.c", 182, "byte < sgen_space_bitmap_size");
  <D.22099>:
  byte.147 = (sizetype) byte;
  D.22101 = space_bitmap + byte.147;
  byte.147 = (sizetype) byte;
  D.22101 = space_bitmap + byte.147;
  D.22102 = *D.22101;
  D.22103 = (signed char) D.22102;
  D.22104 = 1 << bit;
  D.22105 = (signed char) D.22104;
  D.22106 = D.22103 | D.22105;
  D.22107 = (char) D.22106;
  *D.22101 = D.22107;
}


minor_par_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int D.22108;
  char * D.22111;
  void * (*<T3846>) (struct MonoVTable *, int, gboolean) D.22112;
  int objsize.148;

  D.22108 = sgen_ptr_in_nursery (obj);
  if (D.22108 == 0) goto <D.22109>; else goto <D.22110>;
  <D.22109>:
  D.22112 = major_collector.par_alloc_object;
  objsize.148 = (int) objsize;
  D.22111 = D.22112 (vtable, objsize.148, has_references);
  return D.22111;
  <D.22110>:
  D.22111 = par_alloc_for_promotion (vtable, obj, objsize, has_references);
  return D.22111;
}


minor_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int D.22115;
  char * D.22118;
  void * (*<T3846>) (struct MonoVTable *, int, gboolean) D.22119;
  int objsize.149;

  D.22115 = sgen_ptr_in_nursery (obj);
  if (D.22115 == 0) goto <D.22116>; else goto <D.22117>;
  <D.22116>:
  D.22119 = major_collector.alloc_object;
  objsize.149 = (int) objsize;
  D.22118 = D.22119 (vtable, objsize.149, has_references);
  return D.22118;
  <D.22117>:
  D.22118 = alloc_for_promotion (vtable, obj, objsize, has_references);
  return D.22118;
}