__attribute__((visibility ("hidden")))
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)
{
  long unsigned int D.18693;
  long unsigned int D.18694;
  long unsigned int D.18697;
  long unsigned int D.18698;
  long unsigned int D.18699;
  long unsigned int D.18700;
  long unsigned int D.18701;
  long unsigned int D.18702;
  void * D.18707;
  struct FILE * gc_debug_file.0;
  long unsigned int D.18717;
  long unsigned int D.18718;
  int D.18719;
  void * D.18724;
  long unsigned int D.18727;
  long unsigned int D.18728;
  int D.18729;
  long unsigned int D.18736;
  long unsigned int D.18739;
  int D.18740;
  int D.18741;
  unsigned int D.18744;
  unsigned int el_size.1;
  unsigned int D.18746;
  sizetype D.18747;
  void * D.18752;
  int D.18758;
  int D.18759;
  long unsigned int D.18760;
  long unsigned int D.18761;
  long unsigned int D.18762;
  long unsigned int D.18763;
  void * * D.18764;
  void * D.18769;
  sizetype D.18772;
  long unsigned int D.18776;
  void * D.18783;
  long unsigned int D.18786;
  void * D.18793;
  long unsigned int D.18796;
  unsigned int D.18797;
  unsigned int D.18798;
  struct MonoVTable * D.18801;
  struct MonoClass * D.18802;
  const char * D.18803;
  const char * D.18804;
  gsize * bitmap_data.2;
  long unsigned int D.18806;
  void * D.18813;
  int bwords.3;

  start = start + 18446744073709551600;
  D.18693 = desc & 7;
  switch (D.18693) <default: <D.18688>, case 1: <D.18614>, case 2: <D.18623>, case 3: <D.18673>, case 4: <D.18633>, case 5: <D.18666>, case 7: <D.18687>>
  <D.18614>:
  D.18694 = desc & 4294901760;
  if (D.18694 != 0) goto <D.18695>; else goto <D.18696>;
  <D.18695>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.18697 = desc >> 16;
    D.18698 = D.18697 & 255;
    D.18699 = D.18698 * 8;
    _objptr = _objptr + D.18699;
    D.18700 = desc >> 24;
    D.18701 = D.18700 & 255;
    D.18702 = D.18701 * 8;
    _objptr_end = _objptr + D.18702;
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.18703>; else goto <D.18704>;
      <D.18703>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.18705>; else goto <D.18706>;
      <D.18705>:
      D.18707 = *_objptr;
      if (D.18707 != __old) goto <D.18708>; else goto <D.18709>;
      <D.18708>:
      gc_debug_file.0 = gc_debug_file;
      D.18707 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18707, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.18709>:
      <D.18706>:
      <D.18704>:
    }
    _objptr = _objptr + 8;
    goto <D.18620>;
    <D.18619>:
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.18711>; else goto <D.18712>;
      <D.18711>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.18713>; else goto <D.18714>;
      <D.18713>:
      D.18707 = *_objptr;
      if (D.18707 != __old) goto <D.18715>; else goto <D.18716>;
      <D.18715>:
      gc_debug_file.0 = gc_debug_file;
      D.18707 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18707, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.18716>:
      <D.18714>:
      <D.18712>:
    }
    _objptr = _objptr + 8;
    <D.18620>:
    if (_objptr < _objptr_end) goto <D.18619>; else goto <D.18621>;
    <D.18621>:
  }
  <D.18696>:
  goto <D.18622>;
  <D.18623>:
  {
    void * * _objptr;
    gsize _bmap;

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

      _index = __builtin_ctzl (_bmap);
      D.18717 = (long unsigned int) _index;
      D.18718 = D.18717 * 8;
      _objptr = _objptr + D.18718;
      D.18719 = _index + 1;
      _bmap = _bmap >> D.18719;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.18720>; else goto <D.18721>;
        <D.18720>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.18722>; else goto <D.18723>;
        <D.18722>:
        D.18724 = *_objptr;
        if (D.18724 != __old) goto <D.18725>; else goto <D.18726>;
        <D.18725>:
        gc_debug_file.0 = gc_debug_file;
        D.18724 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18724, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.18726>:
        <D.18723>:
        <D.18721>:
      }
      _objptr = _objptr + 8;
    }
    goto <D.18631>;
    <D.18630>:
    {
      int _index;

      _index = __builtin_ctzl (_bmap);
      D.18727 = (long unsigned int) _index;
      D.18728 = D.18727 * 8;
      _objptr = _objptr + D.18728;
      D.18729 = _index + 1;
      _bmap = _bmap >> D.18729;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.18730>; else goto <D.18731>;
        <D.18730>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.18732>; else goto <D.18733>;
        <D.18732>:
        D.18724 = *_objptr;
        if (D.18724 != __old) goto <D.18734>; else goto <D.18735>;
        <D.18734>:
        gc_debug_file.0 = gc_debug_file;
        D.18724 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18724, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.18735>:
        <D.18733>:
        <D.18731>:
      }
      _objptr = _objptr + 8;
    }
    <D.18631>:
    if (_bmap != 0) goto <D.18630>; else goto <D.18632>;
    <D.18632>:
  }
  goto <D.18622>;
  <D.18633>:
  D.18736 = desc & 4294950912;
  if (D.18736 != 0) goto <D.18737>; else goto <D.18738>;
  <D.18737>:
  {
    int el_size;
    int etype;

    D.18739 = desc >> 3;
    D.18740 = (int) D.18739;
    el_size = D.18740 & 1023;
    D.18741 = (int) desc;
    etype = D.18741 & 49152;
    if (etype == 16384) goto <D.18742>; else goto <D.18743>;
    <D.18742>:
    {
      void * * p;
      void * * end_refs;

      p = start + 32;
      D.18744 = MEM[(struct MonoArray *)start].max_length;
      el_size.1 = (unsigned int) el_size;
      D.18746 = D.18744 * el_size.1;
      D.18747 = (sizetype) D.18746;
      end_refs = p + D.18747;
      goto <D.18640>;
      <D.18639>:
      {
        void * __old;

        __old = *p;
        if (__old != 0B) goto <D.18748>; else goto <D.18749>;
        <D.18748>:
        split_nursery_serial_copy_object_from_obj (p, queue);
        if (0 != 0) goto <D.18750>; else goto <D.18751>;
        <D.18750>:
        D.18752 = *p;
        if (D.18752 != __old) goto <D.18753>; else goto <D.18754>;
        <D.18753>:
        gc_debug_file.0 = gc_debug_file;
        D.18752 = *p;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", p, D.18752, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.18754>:
        <D.18751>:
        <D.18749>:
      }
      p = p + 8;
      <D.18640>:
      if (p < end_refs) goto <D.18639>; else goto <D.18641>;
      <D.18641>:
    }
    goto <D.18755>;
    <D.18743>:
    if (etype == 32768) goto <D.18756>; else goto <D.18757>;
    <D.18756>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.18697 = desc >> 16;
      D.18758 = (int) D.18697;
      offset = D.18758 & 255;
      D.18700 = desc >> 24;
      D.18759 = (int) D.18700;
      num_refs = D.18759 & 255;
      e_start = start + 32;
      D.18744 = MEM[(struct MonoArray *)start].max_length;
      el_size.1 = (unsigned int) el_size;
      D.18746 = D.18744 * el_size.1;
      D.18747 = (sizetype) D.18746;
      e_end = e_start + D.18747;
      goto <D.18653>;
      <D.18652>:
      {
        void * * p;
        int i;

        p = e_start;
        D.18760 = (long unsigned int) offset;
        D.18761 = D.18760 * 8;
        p = p + D.18761;
        i = 0;
        goto <D.18650>;
        <D.18649>:
        {
          void * __old;

          D.18762 = (long unsigned int) i;
          D.18763 = D.18762 * 8;
          D.18764 = p + D.18763;
          __old = *D.18764;
          if (__old != 0B) goto <D.18765>; else goto <D.18766>;
          <D.18765>:
          D.18762 = (long unsigned int) i;
          D.18763 = D.18762 * 8;
          D.18764 = p + D.18763;
          split_nursery_serial_copy_object_from_obj (D.18764, queue);
          if (0 != 0) goto <D.18767>; else goto <D.18768>;
          <D.18767>:
          D.18762 = (long unsigned int) i;
          D.18763 = D.18762 * 8;
          D.18764 = p + D.18763;
          D.18769 = *D.18764;
          if (D.18769 != __old) goto <D.18770>; else goto <D.18771>;
          <D.18770>:
          gc_debug_file.0 = gc_debug_file;
          D.18762 = (long unsigned int) i;
          D.18763 = D.18762 * 8;
          D.18764 = p + D.18763;
          D.18762 = (long unsigned int) i;
          D.18763 = D.18762 * 8;
          D.18764 = p + D.18763;
          D.18769 = *D.18764;
          fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", D.18764, D.18769, __old);
          gc_debug_file.0 = gc_debug_file;
          fflush (gc_debug_file.0);
          <D.18771>:
          <D.18768>:
          <D.18766>:
        }
        i = i + 1;
        <D.18650>:
        if (i < num_refs) goto <D.18649>; else goto <D.18651>;
        <D.18651>:
        D.18772 = (sizetype) el_size;
        e_start = e_start + D.18772;
      }
      <D.18653>:
      if (e_start < e_end) goto <D.18652>; else goto <D.18654>;
      <D.18654>:
    }
    goto <D.18773>;
    <D.18757>:
    if (etype == 49152) goto <D.18774>; else goto <D.18775>;
    <D.18774>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 32;
      D.18744 = MEM[(struct MonoArray *)start].max_length;
      el_size.1 = (unsigned int) el_size;
      D.18746 = D.18744 * el_size.1;
      D.18747 = (sizetype) D.18746;
      e_end = e_start + D.18747;
      goto <D.18664>;
      <D.18663>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.18661>;
        <D.18660>:
        D.18776 = _bmap & 1;
        if (D.18776 != 0) goto <D.18777>; else goto <D.18778>;
        <D.18777>:
        {
          void * __old;

          __old = *p;
          if (__old != 0B) goto <D.18779>; else goto <D.18780>;
          <D.18779>:
          split_nursery_serial_copy_object_from_obj (p, queue);
          if (0 != 0) goto <D.18781>; else goto <D.18782>;
          <D.18781>:
          D.18783 = *p;
          if (D.18783 != __old) goto <D.18784>; else goto <D.18785>;
          <D.18784>:
          gc_debug_file.0 = gc_debug_file;
          D.18783 = *p;
          fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", p, D.18783, __old);
          gc_debug_file.0 = gc_debug_file;
          fflush (gc_debug_file.0);
          <D.18785>:
          <D.18782>:
          <D.18780>:
        }
        <D.18778>:
        _bmap = _bmap >> 1;
        p = p + 8;
        <D.18661>:
        if (_bmap != 0) goto <D.18660>; else goto <D.18662>;
        <D.18662>:
        D.18772 = (sizetype) el_size;
        e_start = e_start + D.18772;
      }
      <D.18664>:
      if (e_start < e_end) goto <D.18663>; else goto <D.18665>;
      <D.18665>:
    }
    <D.18775>:
    <D.18773>:
    <D.18755>:
  }
  <D.18738>:
  goto <D.18622>;
  <D.18666>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 3;
    _objptr = _objptr + 16;
    goto <D.18671>;
    <D.18670>:
    D.18786 = _bmap & 1;
    if (D.18786 != 0) goto <D.18787>; else goto <D.18788>;
    <D.18787>:
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.18789>; else goto <D.18790>;
      <D.18789>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.18791>; else goto <D.18792>;
      <D.18791>:
      D.18793 = *_objptr;
      if (D.18793 != __old) goto <D.18794>; else goto <D.18795>;
      <D.18794>:
      gc_debug_file.0 = gc_debug_file;
      D.18793 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18793, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.18795>:
      <D.18792>:
      <D.18790>:
    }
    <D.18788>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 8;
    <D.18671>:
    if (_bmap != 0) goto <D.18670>; else goto <D.18672>;
    <D.18672>:
  }
  goto <D.18622>;
  <D.18673>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.18796 = *bitmap_data;
    D.18797 = (unsigned int) D.18796;
    D.18798 = D.18797 + 4294967295;
    bwords = (int) D.18798;
    start_run = _objptr;
    bitmap_data = bitmap_data + 8;
    if (0 != 0) goto <D.18799>; else goto <D.18800>;
    <D.18799>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.18801 = myobj->vtable;
      D.18802 = D.18801->klass;
      D.18803 = D.18802->name_space;
      D.18801 = myobj->vtable;
      D.18802 = D.18801->klass;
      D.18804 = D.18802->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18803, D.18804);
    }
    <D.18800>:
    goto <D.18685>;
    <D.18684>:
    {
      gsize _bmap;

      bitmap_data.2 = bitmap_data;
      bitmap_data = bitmap_data.2 + 8;
      _bmap = *bitmap_data.2;
      _objptr = start_run;
      goto <D.18682>;
      <D.18681>:
      D.18806 = _bmap & 1;
      if (D.18806 != 0) goto <D.18807>; else goto <D.18808>;
      <D.18807>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.18809>; else goto <D.18810>;
        <D.18809>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.18811>; else goto <D.18812>;
        <D.18811>:
        D.18813 = *_objptr;
        if (D.18813 != __old) goto <D.18814>; else goto <D.18815>;
        <D.18814>:
        gc_debug_file.0 = gc_debug_file;
        D.18813 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18813, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.18815>:
        <D.18812>:
        <D.18810>:
      }
      <D.18808>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18682>:
      if (_bmap != 0) goto <D.18681>; else goto <D.18683>;
      <D.18683>:
      start_run = start_run + 512;
    }
    <D.18685>:
    bwords.3 = bwords;
    bwords = bwords.3 + -1;
    if (bwords.3 > 0) goto <D.18684>; else goto <D.18686>;
    <D.18686>:
  }
  goto <D.18622>;
  <D.18687>:
  goto <D.18622>;
  <D.18688>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.18622>:
}


__attribute__((always_inline))
split_nursery_serial_copy_object_from_obj (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.4;
  int D.18821;
  struct FILE * gc_debug_file.5;
  char * iftmp.6;
  long unsigned int D.18828;
  long unsigned int D.18829;
  long unsigned int D.18832;
  int iftmp.7;
  int D.18843;
  int D.18845;
  _Bool D.18847;
  long int D.18848;
  long int D.18849;
  long unsigned int D.18852;
  _Bool D.18853;
  long int D.18854;
  long int D.18855;
  int D.18862;
  int D.18865;
  int D.18872;
  int iftmp.8;
  int D.18878;
  int D.18880;
  _Bool D.18882;
  long int D.18883;
  long int D.18884;
  char * forwarded;
  char * obj;
  void * copy;

  obj = *obj_slot;
  if (0 != 0) goto <D.18818>; else goto <D.18819>;
  <D.18818>:
  current_collection_generation.4 = current_collection_generation;
  monoeg_g_log (0B, 4, "calling minor-serial-copy-from-obj from a %d generation collection", current_collection_generation.4);
  <D.18290>:
  goto <D.18290>;
  <D.18819>:
  D.18821 = sgen_ptr_in_nursery (obj);
  if (D.18821 == 0) goto <D.18822>; else goto <D.18823>;
  <D.18822>:
  return;
  <D.18823>:
  if (0 != 0) goto <D.18824>; else goto <D.18825>;
  <D.18824>:
  gc_debug_file.5 = gc_debug_file;
  fprintf (gc_debug_file.5, "Precise copy of %p from %p\n", obj, obj_slot);
  gc_debug_file.5 = gc_debug_file;
  fflush (gc_debug_file.5);
  <D.18825>:
  D.18828 = MEM[(mword *)obj];
  D.18829 = D.18828 & 1;
  if (D.18829 != 0) goto <D.18830>; else goto <D.18831>;
  <D.18830>:
  D.18828 = MEM[(mword *)obj];
  D.18832 = D.18828 & 18446744073709551612;
  iftmp.6 = (char *) D.18832;
  goto <D.18833>;
  <D.18831>:
  iftmp.6 = 0B;
  <D.18833>:
  forwarded = iftmp.6;
  if (forwarded != 0B) goto <D.18834>; else goto <D.18835>;
  <D.18834>:
  if (0 != 0) goto <D.18836>; else goto <D.18837>;
  <D.18836>:
  monoeg_g_log (0B, 4, "forwarded object %p has no gc descriptor", forwarded);
  <D.18291>:
  goto <D.18291>;
  <D.18837>:
  if (0 != 0) goto <D.18838>; else goto <D.18839>;
  <D.18838>:
  gc_debug_file.5 = gc_debug_file;
  fprintf (gc_debug_file.5, " (already forwarded to %p)\n", forwarded);
  gc_debug_file.5 = gc_debug_file;
  fflush (gc_debug_file.5);
  <D.18839>:
  *obj_slot = forwarded;
  D.18843 = sgen_ptr_in_nursery (forwarded);
  if (D.18843 != 0) goto <D.18844>; else goto <D.18841>;
  <D.18844>:
  D.18845 = sgen_ptr_in_nursery (obj_slot);
  if (D.18845 == 0) goto <D.18846>; else goto <D.18841>;
  <D.18846>:
  iftmp.7 = 1;
  goto <D.18842>;
  <D.18841>:
  iftmp.7 = 0;
  <D.18842>:
  D.18847 = iftmp.7 != 0;
  D.18848 = (long int) D.18847;
  D.18849 = __builtin_expect (D.18848, 0);
  if (D.18849 != 0) goto <D.18850>; else goto <D.18851>;
  <D.18850>:
  sgen_add_to_global_remset (obj_slot, forwarded);
  <D.18851>:
  return;
  <D.18835>:
  D.18828 = MEM[(mword *)obj];
  D.18852 = D.18828 & 2;
  D.18853 = D.18852 != 0;
  D.18854 = (long int) D.18853;
  D.18855 = __builtin_expect (D.18854, 0);
  if (D.18855 != 0) goto <D.18856>; else goto <D.18857>;
  <D.18856>:
  if (0 != 0) goto <D.18858>; else goto <D.18859>;
  <D.18858>:
  monoeg_g_log (0B, 4, "pinned object %p has no gc descriptor", obj);
  <D.18292>:
  goto <D.18292>;
  <D.18859>:
  if (0 != 0) goto <D.18860>; else goto <D.18861>;
  <D.18860>:
  gc_debug_file.5 = gc_debug_file;
  fprintf (gc_debug_file.5, " (pinned, no change)\n");
  gc_debug_file.5 = gc_debug_file;
  fflush (gc_debug_file.5);
  <D.18861>:
  D.18862 = sgen_ptr_in_nursery (obj_slot);
  if (D.18862 == 0) goto <D.18863>; else goto <D.18864>;
  <D.18863>:
  sgen_add_to_global_remset (obj_slot, obj);
  <D.18864>:
  return;
  <D.18857>:
  D.18865 = sgen_nursery_is_to_space (obj);
  if (D.18865 != 0) goto <D.18866>; else goto <D.18867>;
  <D.18866>:
  if (0 != 0) goto <D.18868>; else goto <D.18869>;
  <D.18868>:
  monoeg_g_log (0B, 4, "to space object %p has no gc descriptor", obj);
  <D.18293>:
  goto <D.18293>;
  <D.18869>:
  if (0 != 0) goto <D.18870>; else goto <D.18871>;
  <D.18870>:
  gc_debug_file.5 = gc_debug_file;
  fprintf (gc_debug_file.5, " (tospace, no change)\n");
  gc_debug_file.5 = gc_debug_file;
  fflush (gc_debug_file.5);
  <D.18871>:
  D.18872 = sgen_ptr_in_nursery (obj_slot);
  if (D.18872 == 0) goto <D.18873>; else goto <D.18874>;
  <D.18873>:
  sgen_add_to_global_remset (obj_slot, obj);
  <D.18874>:
  return;
  <D.18867>:
  copy = copy_object_no_checks (obj, queue);
  *obj_slot = copy;
  D.18878 = sgen_ptr_in_nursery (copy);
  if (D.18878 != 0) goto <D.18879>; else goto <D.18876>;
  <D.18879>:
  D.18880 = sgen_ptr_in_nursery (obj_slot);
  if (D.18880 == 0) goto <D.18881>; else goto <D.18876>;
  <D.18881>:
  iftmp.8 = 1;
  goto <D.18877>;
  <D.18876>:
  iftmp.8 = 0;
  <D.18877>:
  D.18882 = iftmp.8 != 0;
  D.18883 = (long int) D.18882;
  D.18884 = __builtin_expect (D.18883, 0);
  if (D.18884 != 0) goto <D.18885>; else goto <D.18886>;
  <D.18885>:
  sgen_add_to_global_remset (obj_slot, copy);
  <D.18886>:
}


sgen_nursery_is_to_space (char * object)
{
  long int object.9;
  char * sgen_nursery_start.10;
  long int sgen_nursery_start.11;
  long int D.18891;
  long int D.18892;
  int D.18893;
  _Bool D.18894;
  long int D.18895;
  long int D.18896;
  char * D.18899;
  char * D.18900;
  int sgen_space_bitmap_size.12;
  _Bool D.18902;
  long int D.18903;
  long int D.18904;
  gboolean D.18907;
  char * sgen_space_bitmap.13;
  sizetype D.18909;
  char * D.18910;
  char D.18911;
  int D.18912;
  int D.18913;
  int D.18914;
  _Bool D.18915;
  int idx;
  int byte;
  int bit;

  object.9 = (long int) object;
  sgen_nursery_start.10 = sgen_nursery_start;
  sgen_nursery_start.11 = (long int) sgen_nursery_start.10;
  D.18891 = object.9 - sgen_nursery_start.11;
  D.18892 = D.18891 >> 9;
  idx = (int) D.18892;
  byte = idx / 8;
  bit = idx & 7;
  D.18893 = sgen_ptr_in_nursery (object);
  D.18894 = D.18893 == 0;
  D.18895 = (long int) D.18894;
  D.18896 = __builtin_expect (D.18895, 0);
  if (D.18896 != 0) goto <D.18897>; else goto <D.18898>;
  <D.18897>:
  D.18899 = sgen_get_nursery_start ();
  D.18900 = sgen_get_nursery_end ();
  monoeg_g_log (0B, 4, "object %p is not in nursery [%p - %p]", object, D.18899, D.18900);
  <D.17576>:
  goto <D.17576>;
  <D.18898>:
  sgen_space_bitmap_size.12 = sgen_space_bitmap_size;
  D.18902 = byte >= sgen_space_bitmap_size.12;
  D.18903 = (long int) D.18902;
  D.18904 = __builtin_expect (D.18903, 0);
  if (D.18904 != 0) goto <D.18905>; else goto <D.18906>;
  <D.18905>:
  sgen_space_bitmap_size.12 = sgen_space_bitmap_size;
  monoeg_g_log (0B, 4, "byte index %d out of range", byte, sgen_space_bitmap_size.12);
  <D.17577>:
  goto <D.17577>;
  <D.18906>:
  sgen_space_bitmap.13 = sgen_space_bitmap;
  D.18909 = (sizetype) byte;
  D.18910 = sgen_space_bitmap.13 + D.18909;
  D.18911 = *D.18910;
  D.18912 = (int) D.18911;
  D.18913 = D.18912 >> bit;
  D.18914 = D.18913 & 1;
  D.18915 = D.18914 != 0;
  D.18907 = (gboolean) D.18915;
  return D.18907;
}


__attribute__((always_inline))
sgen_get_nursery_start ()
{
  char * D.18917;

  D.18917 = sgen_nursery_start;
  return D.18917;
}


__attribute__((always_inline))
sgen_get_nursery_end ()
{
  char * D.18919;

  D.18919 = sgen_nursery_end;
  return D.18919;
}


__attribute__((__unused__, noinline))
copy_object_no_checks (void * obj, struct SgenGrayQueue * queue)
{
  void * D.18921;
  long unsigned int D.18922;
  unsigned int D.18923;
  unsigned int D.18924;
  long unsigned int D.18925;
  _Bool D.18926;
  long int D.18927;
  long int D.18928;
  void * D.18931;
  struct SgenGrayQueue * iftmp.14;
  long unsigned int destination.15;
  long unsigned int D.18937;
  struct MonoVTable * vt;
  gboolean has_references;
  mword objsize;
  char * destination;

  vt = MEM[(struct MonoObject *)obj].vtable;
  D.18921 = vt->gc_descr;
  D.18922 = (long unsigned int) D.18921;
  has_references = sgen_gc_descr_has_references (D.18922);
  D.18923 = sgen_par_object_get_size (vt, obj);
  D.18924 = D.18923 + 7;
  D.18925 = (long unsigned int) D.18924;
  objsize = D.18925 & 4294967288;
  destination = alloc_for_promotion (vt, obj, objsize, has_references);
  D.18926 = destination == 0B;
  D.18927 = (long int) D.18926;
  D.18928 = __builtin_expect (D.18927, 0);
  if (D.18928 != 0) goto <D.18929>; else goto <D.18930>;
  <D.18929>:
  sgen_pin_object (obj, queue);
  sgen_set_pinned_from_failed_allocation (objsize);
  D.18931 = obj;
  return D.18931;
  <D.18930>:
  if (has_references != 0) goto <D.18933>; else goto <D.18934>;
  <D.18933>:
  iftmp.14 = queue;
  goto <D.18935>;
  <D.18934>:
  iftmp.14 = 0B;
  <D.18935>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.14);
  destination.15 = (long unsigned int) destination;
  D.18937 = destination.15 | 1;
  MEM[(mword *)obj] = D.18937;
  D.18931 = destination;
  return D.18931;
}


sgen_gc_descr_has_references (mword desc)
{
  long unsigned int D.18939;
  gboolean D.18942;
  long unsigned int D.18943;
  long unsigned int D.18946;

  D.18939 = desc & 4294901767;
  if (D.18939 == 1) goto <D.18940>; else goto <D.18941>;
  <D.18940>:
  D.18942 = 0;
  return D.18942;
  <D.18941>:
  D.18943 = desc & 49159;
  if (D.18943 == 4) goto <D.18944>; else goto <D.18945>;
  <D.18944>:
  D.18942 = 0;
  return D.18942;
  <D.18945>:
  D.18946 = desc & 7;
  if (D.18946 == 7) goto <D.18947>; else goto <D.18948>;
  <D.18947>:
  D.18942 = 0;
  return D.18942;
  <D.18948>:
  D.18942 = 1;
  return D.18942;
}


sgen_par_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  void * D.18950;
  long unsigned int D.18951;
  guint D.18956;
  int D.18957;
  int D.18958;
  unsigned int D.18959;
  long unsigned int D.18962;
  int D.18963;
  unsigned int D.18964;
  unsigned int element_size.16;
  unsigned int D.18966;
  long unsigned int D.18967;
  long unsigned int D.18968;
  struct MonoClass * D.18971;
  unsigned char D.18972;
  long unsigned int D.18973;
  long unsigned int D.18974;
  mword descr;
  mword type;

  D.18950 = vtable->gc_descr;
  descr = (mword) D.18950;
  type = descr & 7;
  D.18951 = type + 18446744073709551615;
  if (D.18951 <= 1) goto <D.18952>; else goto <D.18953>;
  <D.18952>:
  {
    mword size;

    size = descr & 65528;
    if (size == 0) goto <D.18954>; else goto <D.18955>;
    <D.18954>:
    D.18957 = MEM[(struct MonoString *)o].length;
    D.18958 = D.18957 * 2;
    D.18959 = (unsigned int) D.18958;
    D.18956 = D.18959 + 26;
    return D.18956;
    <D.18955>:
    D.18956 = (guint) size;
    return D.18956;
  }
  <D.18953>:
  if (type == 4) goto <D.18960>; else goto <D.18961>;
  <D.18960>:
  {
    int element_size;
    struct MonoArray * array;
    size_t size;

    D.18962 = descr >> 3;
    D.18963 = (int) D.18962;
    element_size = D.18963 & 1023;
    array = o;
    D.18964 = array->max_length;
    element_size.16 = (unsigned int) element_size;
    D.18966 = D.18964 * element_size.16;
    D.18967 = (long unsigned int) D.18966;
    size = D.18967 + 32;
    D.18968 = descr & 8192;
    if (D.18968 != 0) goto <D.18969>; else goto <D.18970>;
    <D.18969>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.18971 = vtable->klass;
    D.18972 = D.18971->rank;
    D.18973 = (long unsigned int) D.18972;
    D.18974 = D.18973 * 8;
    size = D.18974 + size;
    <D.18970>:
    D.18956 = (guint) size;
    return D.18956;
  }
  <D.18961>:
  D.18956 = slow_object_get_size (vtable, o);
  return D.18956;
}


slow_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  struct MonoClass * D.18976;
  guint D.18979;
  int D.18980;
  int D.18981;
  unsigned int D.18982;
  unsigned char D.18983;
  int D.18986;
  unsigned int D.18987;
  unsigned int D.18988;
  unsigned int D.18989;
  long unsigned int D.18990;
  struct MonoArrayBounds * D.18991;
  _Bool D.18992;
  long int D.18993;
  long int D.18994;
  long unsigned int D.18997;
  long unsigned int D.18998;
  int D.18999;
  struct MonoClass * klass;

  klass = vtable->klass;
  D.18976 = mono_defaults.string_class;
  if (D.18976 == klass) goto <D.18977>; else goto <D.18978>;
  <D.18977>:
  D.18980 = MEM[(struct MonoString *)o].length;
  D.18981 = D.18980 * 2;
  D.18982 = (unsigned int) D.18981;
  D.18979 = D.18982 + 26;
  return D.18979;
  <D.18978>:
  D.18983 = klass->rank;
  if (D.18983 != 0) goto <D.18984>; else goto <D.18985>;
  <D.18984>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.18986 = klass->sizes.element_size;
    D.18987 = (unsigned int) D.18986;
    D.18988 = array->max_length;
    D.18989 = D.18987 * D.18988;
    D.18990 = (long unsigned int) D.18989;
    size = D.18990 + 32;
    D.18991 = array->bounds;
    D.18992 = D.18991 != 0B;
    D.18993 = (long int) D.18992;
    D.18994 = __builtin_expect (D.18993, 0);
    if (D.18994 != 0) goto <D.18995>; else goto <D.18996>;
    <D.18995>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.18983 = klass->rank;
    D.18997 = (long unsigned int) D.18983;
    D.18998 = D.18997 * 8;
    size = D.18998 + size;
    <D.18996>:
    D.18979 = (guint) size;
    return D.18979;
  }
  <D.18985>:
  D.18999 = klass->instance_size;
  D.18979 = (guint) D.18999;
  return D.18979;
}


alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int promote_age.17;
  char * D.19004;
  void * (*<T2fcb>) (struct MonoVTable *, int, gboolean) D.19005;
  int D.19006;
  char * D.19007;
  char * D.19008;
  _Bool D.19009;
  long int D.19010;
  long int D.19011;
  char * D.19014;
  char * D.19015;
  char * p;
  int age;

  p = 0B;
  age = get_object_age (obj);
  promote_age.17 = promote_age;
  if (age >= promote_age.17) goto <D.19002>; else goto <D.19003>;
  <D.19002>:
  D.19005 = major_collector.alloc_object;
  D.19006 = (int) objsize;
  D.19004 = D.19005 (vtable, D.19006, has_references);
  return D.19004;
  <D.19003>:
  age = age + 1;
  p = age_alloc_buffers[age].next;
  D.19007 = p + objsize;
  D.19008 = age_alloc_buffers[age].end;
  D.19009 = D.19007 <= D.19008;
  D.19010 = (long int) D.19009;
  D.19011 = __builtin_expect (D.19010, 1);
  if (D.19011 != 0) goto <D.19012>; else goto <D.19013>;
  <D.19012>:
  D.19014 = age_alloc_buffers[age].next;
  D.19015 = D.19014 + objsize;
  age_alloc_buffers[age].next = D.19015;
  goto <D.19016>;
  <D.19013>:
  p = alloc_for_promotion_slow_path (age, objsize);
  if (p == 0B) goto <D.19017>; else goto <D.19018>;
  <D.19017>:
  D.19005 = major_collector.alloc_object;
  D.19006 = (int) objsize;
  D.19004 = D.19005 (vtable, D.19006, has_references);
  return D.19004;
  <D.19018>:
  <D.19016>:
  MEM[(struct MonoVTable * *)p] = vtable;
  D.19004 = p;
  return D.19004;
}


get_object_age (char * object)
{
  long int object.18;
  char * sgen_nursery_start.19;
  long int sgen_nursery_start.20;
  long int D.19023;
  long int D.19024;
  int D.19025;
  char * region_age.21;
  sizetype D.19027;
  char * D.19028;
  char D.19029;
  int idx;

  object.18 = (long int) object;
  sgen_nursery_start.19 = sgen_nursery_start;
  sgen_nursery_start.20 = (long int) sgen_nursery_start.19;
  D.19023 = object.18 - sgen_nursery_start.20;
  D.19024 = D.19023 >> 9;
  idx = (int) D.19024;
  region_age.21 = region_age;
  D.19027 = (sizetype) idx;
  D.19028 = region_age.21 + D.19027;
  D.19029 = *D.19028;
  D.19025 = (int) D.19029;
  return D.19025;
}


alloc_for_promotion_slow_path (int age, size_t objsize)
{
  long unsigned int D.19031;
  long unsigned int D.19032;
  long unsigned int D.19033;
  long unsigned int allocated_size.22;
  char * D.19037;
  char * D.19038;
  char * D.19039;
  char * D.19040;
  char * D.19041;
  char * p;
  size_t allocated_size;
  size_t aligned_objsize;

  try
    {
      D.19031 = objsize + 511;
      aligned_objsize = D.19031 & 18446744073709551104;
      D.19032 = MAX_EXPR <aligned_objsize, 4096>;
      D.19033 = MAX_EXPR <aligned_objsize, 512>;
      p = sgen_fragment_allocator_serial_range_alloc (&collector_allocator, D.19032, D.19033, &allocated_size);
      if (p != 0B) goto <D.19034>; else goto <D.19035>;
      <D.19034>:
      allocated_size.22 = allocated_size;
      D.19037 = p + allocated_size.22;
      set_age_in_range (p, D.19037, age);
      D.19038 = age_alloc_buffers[age].next;
      D.19039 = age_alloc_buffers[age].end;
      sgen_clear_range (D.19038, D.19039);
      D.19040 = p + objsize;
      age_alloc_buffers[age].next = D.19040;
      allocated_size.22 = allocated_size;
      D.19037 = p + allocated_size.22;
      age_alloc_buffers[age].end = D.19037;
      <D.19035>:
      D.19041 = p;
      return D.19041;
    }
  finally
    {
      allocated_size = {CLOBBER};
    }
}


set_age_in_range (char * start, char * end, int age)
{
  long int start.23;
  char * sgen_nursery_start.24;
  long int sgen_nursery_start.25;
  long int D.19047;
  long int D.19048;
  char * region_age.26;
  sizetype D.19050;
  long int end.27;
  long int D.19052;
  long int D.19053;
  long unsigned int D.19054;
  char * region_start;
  int region_idx;
  int length;

  start.23 = (long int) start;
  sgen_nursery_start.24 = sgen_nursery_start;
  sgen_nursery_start.25 = (long int) sgen_nursery_start.24;
  D.19047 = start.23 - sgen_nursery_start.25;
  D.19048 = D.19047 >> 9;
  region_idx = (int) D.19048;
  region_age.26 = region_age;
  D.19050 = (sizetype) region_idx;
  region_start = region_age.26 + D.19050;
  end.27 = (long int) end;
  start.23 = (long int) start;
  D.19052 = end.27 - start.23;
  D.19053 = D.19052 >> 9;
  length = (int) D.19053;
  D.19054 = (long unsigned int) length;
  memset (region_start, age, D.19054);
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.19055;
  long unsigned int D.19056;

  D.19056 = __builtin_object_size (__dest, 0);
  D.19055 = __builtin___memset_chk (__dest, __ch, __len, D.19056);
  return D.19055;
}


par_copy_object_no_checks (char * destination, struct MonoVTable * vt, void * obj, mword objsize, struct SgenGrayQueue * queue)
{
  struct MonoClass * D.19060;
  const char * D.19061;
  const char * D.19062;
  struct FILE * gc_debug_file.28;
  struct MonoVTable * D.19066;
  struct MonoClass * D.19067;
  const char * D.19068;
  long unsigned int D.19071;
  const void * D.19072;
  mword * D.19073;
  long unsigned int D.19074;
  mword * D.19075;
  long unsigned int D.19076;
  mword * D.19077;
  long unsigned int D.19078;
  mword * D.19079;
  long unsigned int D.19080;
  mword * D.19081;
  long unsigned int D.19082;
  mword * D.19083;
  long unsigned int D.19084;
  mword * D.19085;
  long unsigned int D.19086;
  char * D.19088;
  const void * D.19089;
  long unsigned int D.19090;
  int iftmp.29;
  unsigned char D.19096;
  struct MonoArrayBounds * D.19098;
  _Bool D.19100;
  long int D.19101;
  long int D.19102;
  long int D.19105;
  long int obj.30;
  long int D.19107;
  sizetype D.19108;
  char * D.19109;
  int D.19112;
  long unsigned int D.19113;
  <unnamed type> mono_profiler_events.31;
  unsigned int D.19115;
  _Bool D.19116;
  long int D.19117;
  long int D.19118;
  const char * D.19125;
  int iftmp.32;
  struct GrayQueueSection * D.19130;
  int D.19132;
  _Bool D.19133;
  long int D.19134;
  long int D.19135;
  int D.19139;
  int D.19140;
  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.19058>; else goto <D.19059>;
  <D.19058>:
  D.19060 = vt->klass;
  D.19061 = D.19060->name_space;
  D.19060 = vt->klass;
  D.19062 = D.19060->name;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s was not initialized", vt, D.19061, D.19062);
  <D.18261>:
  goto <D.18261>;
  <D.19059>:
  if (0 != 0) goto <D.19063>; else goto <D.19064>;
  <D.19063>:
  gc_debug_file.28 = gc_debug_file;
  D.19066 = MEM[(struct MonoObject *)obj].vtable;
  D.19067 = D.19066->klass;
  D.19068 = D.19067->name;
  fprintf (gc_debug_file.28, " (to %p, %s size: %lu)\n", destination, D.19068, objsize);
  gc_debug_file.28 = gc_debug_file;
  fflush (gc_debug_file.28);
  <D.19064>:
  if (objsize <= 64) goto <D.19069>; else goto <D.19070>;
  <D.19069>:
  {
    mword * dest;

    dest = destination;
    D.19071 = objsize / 8;
    D.19072 = copy_labels[D.19071];
    goto D.19072;
    LAB_8:
    D.19073 = dest + 56;
    D.19074 = MEM[(mword *)obj + 56B];
    *D.19073 = D.19074;
    LAB_7:
    D.19075 = dest + 48;
    D.19076 = MEM[(mword *)obj + 48B];
    *D.19075 = D.19076;
    LAB_6:
    D.19077 = dest + 40;
    D.19078 = MEM[(mword *)obj + 40B];
    *D.19077 = D.19078;
    LAB_5:
    D.19079 = dest + 32;
    D.19080 = MEM[(mword *)obj + 32B];
    *D.19079 = D.19080;
    LAB_4:
    D.19081 = dest + 24;
    D.19082 = MEM[(mword *)obj + 24B];
    *D.19081 = D.19082;
    LAB_3:
    D.19083 = dest + 16;
    D.19084 = MEM[(mword *)obj + 16B];
    *D.19083 = D.19084;
    LAB_2:
    D.19085 = dest + 8;
    D.19086 = MEM[(mword *)obj + 8B];
    *D.19085 = D.19086;
    LAB_1:
    LAB_0:
  }
  goto <D.19087>;
  <D.19070>:
  D.19088 = destination + 8;
  D.19089 = obj + 8;
  D.19090 = objsize + 18446744073709551608;
  mono_gc_memmove_aligned (D.19088, D.19089, D.19090);
  <D.19087>:
  if (0 != 0) goto <D.19091>; else goto <D.19092>;
  <D.19091>:
  D.19060 = vt->klass;
  D.19061 = D.19060->name_space;
  D.19060 = vt->klass;
  D.19062 = D.19060->name;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s has no gc descriptor", vt, D.19061, D.19062);
  <D.18263>:
  goto <D.18263>;
  <D.19092>:
  D.19096 = vt->rank;
  if (D.19096 != 0) goto <D.19097>; else goto <D.19094>;
  <D.19097>:
  D.19098 = MEM[(struct MonoArray *)obj].bounds;
  if (D.19098 != 0B) goto <D.19099>; else goto <D.19094>;
  <D.19099>:
  iftmp.29 = 1;
  goto <D.19095>;
  <D.19094>:
  iftmp.29 = 0;
  <D.19095>:
  D.19100 = iftmp.29 != 0;
  D.19101 = (long int) D.19100;
  D.19102 = __builtin_expect (D.19101, 0);
  if (D.19102 != 0) goto <D.19103>; else goto <D.19104>;
  <D.19103>:
  {
    struct MonoArray * array;

    array = destination;
    D.19098 = MEM[(struct MonoArray *)obj].bounds;
    D.19105 = (long int) D.19098;
    obj.30 = (long int) obj;
    D.19107 = D.19105 - obj.30;
    D.19108 = (sizetype) D.19107;
    D.19109 = destination + D.19108;
    array->bounds = D.19109;
    if (0 != 0) goto <D.19110>; else goto <D.19111>;
    <D.19110>:
    gc_debug_file.28 = gc_debug_file;
    D.19096 = vt->rank;
    D.19112 = (int) D.19096;
    D.19113 = mono_array_length (array);
    fprintf (gc_debug_file.28, "Array instance %p: size: %lu, rank: %d, length: %lu\n", array, objsize, D.19112, D.19113);
    gc_debug_file.28 = gc_debug_file;
    fflush (gc_debug_file.28);
    <D.19111>:
  }
  <D.19104>:
  mono_profiler_events.31 = mono_profiler_events;
  D.19115 = mono_profiler_events.31 & 524288;
  D.19116 = D.19115 != 0;
  D.19117 = (long int) D.19116;
  D.19118 = __builtin_expect (D.19117, 0);
  if (D.19118 != 0) goto <D.19119>; else goto <D.19120>;
  <D.19119>:
  sgen_register_moved_object (obj, destination);
  <D.19120>:
  obj = destination;
  if (queue != 0B) goto <D.19121>; else goto <D.19122>;
  <D.19121>:
  if (0 != 0) goto <D.19123>; else goto <D.19124>;
  <D.19123>:
  gc_debug_file.28 = gc_debug_file;
  D.19125 = sgen_safe_name (obj);
  fprintf (gc_debug_file.28, "Enqueuing gray object %p (%s)\n", obj, D.19125);
  gc_debug_file.28 = gc_debug_file;
  fflush (gc_debug_file.28);
  <D.19124>:
  D.19130 = queue->first;
  if (D.19130 == 0B) goto <D.19127>; else goto <D.19131>;
  <D.19131>:
  D.19130 = queue->first;
  D.19132 = D.19130->end;
  if (D.19132 == 125) goto <D.19127>; else goto <D.19128>;
  <D.19127>:
  iftmp.32 = 1;
  goto <D.19129>;
  <D.19128>:
  iftmp.32 = 0;
  <D.19129>:
  D.19133 = iftmp.32 != 0;
  D.19134 = (long int) D.19133;
  D.19135 = __builtin_expect (D.19134, 0);
  if (D.19135 != 0) goto <D.19136>; else goto <D.19137>;
  <D.19136>:
  sgen_gray_object_enqueue (queue, obj);
  goto <D.19138>;
  <D.19137>:
  D.19130 = queue->first;
  D.19130 = queue->first;
  D.19132 = D.19130->end;
  D.19139 = D.19132;
  D.19140 = D.19139 + 1;
  D.19130->end = D.19140;
  D.19130->objects[D.19139] = obj;
  <D.19138>:
  __builtin_prefetch (obj);
  <D.19122>:
}


__attribute__((always_inline))
sgen_ptr_in_nursery (void * p)
{
  gboolean D.19143;
  int sgen_nursery_bits.34;
  int D.19145;
  int D.19146;
  long unsigned int D.19147;
  long unsigned int p.35;
  long unsigned int D.19149;
  char * sgen_nursery_start.36;
  long unsigned int sgen_nursery_start.37;
  _Bool D.19152;

  sgen_nursery_bits.34 = sgen_nursery_bits;
  D.19145 = 1 << sgen_nursery_bits.34;
  D.19146 = -D.19145;
  D.19147 = (long unsigned int) D.19146;
  p.35 = (long unsigned int) p;
  D.19149 = D.19147 & p.35;
  sgen_nursery_start.36 = sgen_nursery_start;
  sgen_nursery_start.37 = (long unsigned int) sgen_nursery_start.36;
  D.19152 = D.19149 == sgen_nursery_start.37;
  D.19143 = (gboolean) D.19152;
  return D.19143;
}


split_nursery_serial_scan_object (char * start, struct SgenGrayQueue * queue)
{
  long unsigned int D.19154;
  long unsigned int D.19155;
  long unsigned int D.19156;
  long unsigned int D.19157;
  long unsigned int D.19160;
  long unsigned int D.19161;
  long unsigned int D.19162;
  long unsigned int D.19163;
  long unsigned int D.19164;
  long unsigned int D.19165;
  void * D.19170;
  struct FILE * gc_debug_file.38;
  long unsigned int D.19180;
  long unsigned int D.19181;
  int D.19182;
  void * D.19187;
  long unsigned int D.19190;
  long unsigned int D.19191;
  int D.19192;
  long unsigned int D.19199;
  long unsigned int D.19202;
  int D.19203;
  int D.19204;
  unsigned int D.19207;
  unsigned int el_size.39;
  unsigned int D.19209;
  sizetype D.19210;
  void * D.19215;
  int D.19221;
  int D.19222;
  long unsigned int D.19223;
  long unsigned int D.19224;
  long unsigned int D.19225;
  long unsigned int D.19226;
  void * * D.19227;
  void * D.19232;
  sizetype D.19235;
  long unsigned int D.19239;
  void * D.19246;
  long unsigned int D.19249;
  void * D.19256;
  long unsigned int D.19259;
  unsigned int D.19260;
  unsigned int D.19261;
  struct MonoVTable * D.19264;
  struct MonoClass * D.19265;
  const char * D.19266;
  const char * D.19267;
  gsize * bitmap_data.40;
  long unsigned int D.19269;
  void * D.19276;
  int bwords.41;
  long unsigned int D.19280;
  gsize * mbitmap_data.42;
  long unsigned int D.19282;
  unsigned int D.19283;
  unsigned int D.19284;
  struct MonoClass * D.19285;
  unsigned int el_size.43;
  unsigned int D.19287;
  sizetype D.19288;
  const char * D.19291;
  const char * D.19292;
  gsize * bitmap_data.44;
  long unsigned int D.19294;
  void * D.19301;
  unsigned int bwords.45;
  sizetype D.19305;

  {
    struct GCVTable * vt;
    mword desc;

    D.19154 = MEM[(mword *)start];
    D.19155 = D.19154 & 18446744073709551612;
    vt = (struct GCVTable *) D.19155;
    desc = vt->desc;
    D.19156 = desc & 7;
    switch (D.19156) <default: <D.18608>, case 1: <D.18513>, case 2: <D.18522>, case 3: <D.18572>, case 4: <D.18532>, case 5: <D.18565>, case 6: <D.18586>, case 7: <D.18607>>
    <D.18513>:
    D.19157 = desc & 4294901760;
    if (D.19157 != 0) goto <D.19158>; else goto <D.19159>;
    <D.19158>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19160 = desc >> 16;
      D.19161 = D.19160 & 255;
      D.19162 = D.19161 * 8;
      _objptr = _objptr + D.19162;
      D.19163 = desc >> 24;
      D.19164 = D.19163 & 255;
      D.19165 = D.19164 * 8;
      _objptr_end = _objptr + D.19165;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19166>; else goto <D.19167>;
        <D.19166>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19168>; else goto <D.19169>;
        <D.19168>:
        D.19170 = *_objptr;
        if (D.19170 != __old) goto <D.19171>; else goto <D.19172>;
        <D.19171>:
        gc_debug_file.38 = gc_debug_file;
        D.19170 = *_objptr;
        fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19170, __old);
        gc_debug_file.38 = gc_debug_file;
        fflush (gc_debug_file.38);
        <D.19172>:
        <D.19169>:
        <D.19167>:
      }
      _objptr = _objptr + 8;
      goto <D.18519>;
      <D.18518>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19174>; else goto <D.19175>;
        <D.19174>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19176>; else goto <D.19177>;
        <D.19176>:
        D.19170 = *_objptr;
        if (D.19170 != __old) goto <D.19178>; else goto <D.19179>;
        <D.19178>:
        gc_debug_file.38 = gc_debug_file;
        D.19170 = *_objptr;
        fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19170, __old);
        gc_debug_file.38 = gc_debug_file;
        fflush (gc_debug_file.38);
        <D.19179>:
        <D.19177>:
        <D.19175>:
      }
      _objptr = _objptr + 8;
      <D.18519>:
      if (_objptr < _objptr_end) goto <D.18518>; else goto <D.18520>;
      <D.18520>:
    }
    <D.19159>:
    goto <D.18521>;
    <D.18522>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.19180 = (long unsigned int) _index;
        D.19181 = D.19180 * 8;
        _objptr = _objptr + D.19181;
        D.19182 = _index + 1;
        _bmap = _bmap >> D.19182;
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.19183>; else goto <D.19184>;
          <D.19183>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.19185>; else goto <D.19186>;
          <D.19185>:
          D.19187 = *_objptr;
          if (D.19187 != __old) goto <D.19188>; else goto <D.19189>;
          <D.19188>:
          gc_debug_file.38 = gc_debug_file;
          D.19187 = *_objptr;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19187, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19189>:
          <D.19186>:
          <D.19184>:
        }
        _objptr = _objptr + 8;
      }
      goto <D.18530>;
      <D.18529>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.19190 = (long unsigned int) _index;
        D.19191 = D.19190 * 8;
        _objptr = _objptr + D.19191;
        D.19192 = _index + 1;
        _bmap = _bmap >> D.19192;
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.19193>; else goto <D.19194>;
          <D.19193>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.19195>; else goto <D.19196>;
          <D.19195>:
          D.19187 = *_objptr;
          if (D.19187 != __old) goto <D.19197>; else goto <D.19198>;
          <D.19197>:
          gc_debug_file.38 = gc_debug_file;
          D.19187 = *_objptr;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19187, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19198>:
          <D.19196>:
          <D.19194>:
        }
        _objptr = _objptr + 8;
      }
      <D.18530>:
      if (_bmap != 0) goto <D.18529>; else goto <D.18531>;
      <D.18531>:
    }
    goto <D.18521>;
    <D.18532>:
    D.19199 = desc & 4294950912;
    if (D.19199 != 0) goto <D.19200>; else goto <D.19201>;
    <D.19200>:
    {
      int el_size;
      int etype;

      D.19202 = desc >> 3;
      D.19203 = (int) D.19202;
      el_size = D.19203 & 1023;
      D.19204 = (int) desc;
      etype = D.19204 & 49152;
      if (etype == 16384) goto <D.19205>; else goto <D.19206>;
      <D.19205>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.19207 = MEM[(struct MonoArray *)start].max_length;
        el_size.39 = (unsigned int) el_size;
        D.19209 = D.19207 * el_size.39;
        D.19210 = (sizetype) D.19209;
        end_refs = p + D.19210;
        goto <D.18539>;
        <D.18538>:
        {
          void * __old;

          __old = *p;
          if (__old != 0B) goto <D.19211>; else goto <D.19212>;
          <D.19211>:
          split_nursery_serial_copy_object_from_obj (p, queue);
          if (0 != 0) goto <D.19213>; else goto <D.19214>;
          <D.19213>:
          D.19215 = *p;
          if (D.19215 != __old) goto <D.19216>; else goto <D.19217>;
          <D.19216>:
          gc_debug_file.38 = gc_debug_file;
          D.19215 = *p;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", p, D.19215, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19217>:
          <D.19214>:
          <D.19212>:
        }
        p = p + 8;
        <D.18539>:
        if (p < end_refs) goto <D.18538>; else goto <D.18540>;
        <D.18540>:
      }
      goto <D.19218>;
      <D.19206>:
      if (etype == 32768) goto <D.19219>; else goto <D.19220>;
      <D.19219>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19160 = desc >> 16;
        D.19221 = (int) D.19160;
        offset = D.19221 & 255;
        D.19163 = desc >> 24;
        D.19222 = (int) D.19163;
        num_refs = D.19222 & 255;
        e_start = start + 32;
        D.19207 = MEM[(struct MonoArray *)start].max_length;
        el_size.39 = (unsigned int) el_size;
        D.19209 = D.19207 * el_size.39;
        D.19210 = (sizetype) D.19209;
        e_end = e_start + D.19210;
        goto <D.18552>;
        <D.18551>:
        {
          void * * p;
          int i;

          p = e_start;
          D.19223 = (long unsigned int) offset;
          D.19224 = D.19223 * 8;
          p = p + D.19224;
          i = 0;
          goto <D.18549>;
          <D.18548>:
          {
            void * __old;

            D.19225 = (long unsigned int) i;
            D.19226 = D.19225 * 8;
            D.19227 = p + D.19226;
            __old = *D.19227;
            if (__old != 0B) goto <D.19228>; else goto <D.19229>;
            <D.19228>:
            D.19225 = (long unsigned int) i;
            D.19226 = D.19225 * 8;
            D.19227 = p + D.19226;
            split_nursery_serial_copy_object_from_obj (D.19227, queue);
            if (0 != 0) goto <D.19230>; else goto <D.19231>;
            <D.19230>:
            D.19225 = (long unsigned int) i;
            D.19226 = D.19225 * 8;
            D.19227 = p + D.19226;
            D.19232 = *D.19227;
            if (D.19232 != __old) goto <D.19233>; else goto <D.19234>;
            <D.19233>:
            gc_debug_file.38 = gc_debug_file;
            D.19225 = (long unsigned int) i;
            D.19226 = D.19225 * 8;
            D.19227 = p + D.19226;
            D.19225 = (long unsigned int) i;
            D.19226 = D.19225 * 8;
            D.19227 = p + D.19226;
            D.19232 = *D.19227;
            fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", D.19227, D.19232, __old);
            gc_debug_file.38 = gc_debug_file;
            fflush (gc_debug_file.38);
            <D.19234>:
            <D.19231>:
            <D.19229>:
          }
          i = i + 1;
          <D.18549>:
          if (i < num_refs) goto <D.18548>; else goto <D.18550>;
          <D.18550>:
          D.19235 = (sizetype) el_size;
          e_start = e_start + D.19235;
        }
        <D.18552>:
        if (e_start < e_end) goto <D.18551>; else goto <D.18553>;
        <D.18553>:
      }
      goto <D.19236>;
      <D.19220>:
      if (etype == 49152) goto <D.19237>; else goto <D.19238>;
      <D.19237>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.19207 = MEM[(struct MonoArray *)start].max_length;
        el_size.39 = (unsigned int) el_size;
        D.19209 = D.19207 * el_size.39;
        D.19210 = (sizetype) D.19209;
        e_end = e_start + D.19210;
        goto <D.18563>;
        <D.18562>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.18560>;
          <D.18559>:
          D.19239 = _bmap & 1;
          if (D.19239 != 0) goto <D.19240>; else goto <D.19241>;
          <D.19240>:
          {
            void * __old;

            __old = *p;
            if (__old != 0B) goto <D.19242>; else goto <D.19243>;
            <D.19242>:
            split_nursery_serial_copy_object_from_obj (p, queue);
            if (0 != 0) goto <D.19244>; else goto <D.19245>;
            <D.19244>:
            D.19246 = *p;
            if (D.19246 != __old) goto <D.19247>; else goto <D.19248>;
            <D.19247>:
            gc_debug_file.38 = gc_debug_file;
            D.19246 = *p;
            fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", p, D.19246, __old);
            gc_debug_file.38 = gc_debug_file;
            fflush (gc_debug_file.38);
            <D.19248>:
            <D.19245>:
            <D.19243>:
          }
          <D.19241>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.18560>:
          if (_bmap != 0) goto <D.18559>; else goto <D.18561>;
          <D.18561>:
          D.19235 = (sizetype) el_size;
          e_start = e_start + D.19235;
        }
        <D.18563>:
        if (e_start < e_end) goto <D.18562>; else goto <D.18564>;
        <D.18564>:
      }
      <D.19238>:
      <D.19236>:
      <D.19218>:
    }
    <D.19201>:
    goto <D.18521>;
    <D.18565>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.18570>;
      <D.18569>:
      D.19249 = _bmap & 1;
      if (D.19249 != 0) goto <D.19250>; else goto <D.19251>;
      <D.19250>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19252>; else goto <D.19253>;
        <D.19252>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19254>; else goto <D.19255>;
        <D.19254>:
        D.19256 = *_objptr;
        if (D.19256 != __old) goto <D.19257>; else goto <D.19258>;
        <D.19257>:
        gc_debug_file.38 = gc_debug_file;
        D.19256 = *_objptr;
        fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19256, __old);
        gc_debug_file.38 = gc_debug_file;
        fflush (gc_debug_file.38);
        <D.19258>:
        <D.19255>:
        <D.19253>:
      }
      <D.19251>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18570>:
      if (_bmap != 0) goto <D.18569>; else goto <D.18571>;
      <D.18571>:
    }
    goto <D.18521>;
    <D.18572>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19259 = *bitmap_data;
      D.19260 = (unsigned int) D.19259;
      D.19261 = D.19260 + 4294967295;
      bwords = (int) D.19261;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.19262>; else goto <D.19263>;
      <D.19262>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19264 = myobj->vtable;
        D.19265 = D.19264->klass;
        D.19266 = D.19265->name_space;
        D.19264 = myobj->vtable;
        D.19265 = D.19264->klass;
        D.19267 = D.19265->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19266, D.19267);
      }
      <D.19263>:
      goto <D.18584>;
      <D.18583>:
      {
        gsize _bmap;

        bitmap_data.40 = bitmap_data;
        bitmap_data = bitmap_data.40 + 8;
        _bmap = *bitmap_data.40;
        _objptr = start_run;
        goto <D.18581>;
        <D.18580>:
        D.19269 = _bmap & 1;
        if (D.19269 != 0) goto <D.19270>; else goto <D.19271>;
        <D.19270>:
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.19272>; else goto <D.19273>;
          <D.19272>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.19274>; else goto <D.19275>;
          <D.19274>:
          D.19276 = *_objptr;
          if (D.19276 != __old) goto <D.19277>; else goto <D.19278>;
          <D.19277>:
          gc_debug_file.38 = gc_debug_file;
          D.19276 = *_objptr;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19276, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19278>:
          <D.19275>:
          <D.19273>:
        }
        <D.19271>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18581>:
        if (_bmap != 0) goto <D.18580>; else goto <D.18582>;
        <D.18582>:
        start_run = start_run + 512;
      }
      <D.18584>:
      bwords.41 = bwords;
      bwords = bwords.41 + -1;
      if (bwords.41 > 0) goto <D.18583>; else goto <D.18585>;
      <D.18585>:
    }
    goto <D.18521>;
    <D.18586>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19280 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19280);
      mbitmap_data.42 = mbitmap_data;
      mbitmap_data = mbitmap_data.42 + 8;
      D.19282 = *mbitmap_data.42;
      D.19283 = (unsigned int) D.19282;
      D.19284 = D.19283 + 4294967295;
      mbwords = (int) D.19284;
      D.19285 = vt->klass;
      el_size = mono_array_element_size (D.19285);
      e_start = start + 32;
      D.19207 = MEM[(struct MonoArray *)start].max_length;
      el_size.43 = (unsigned int) el_size;
      D.19287 = D.19207 * el_size.43;
      D.19288 = (sizetype) D.19287;
      e_end = e_start + D.19288;
      if (0 != 0) goto <D.19289>; else goto <D.19290>;
      <D.19289>:
      D.19280 = vt->desc;
      D.19285 = vt->klass;
      D.19291 = D.19285->name_space;
      D.19285 = vt->klass;
      D.19292 = D.19285->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19280, D.19291, D.19292);
      <D.19290>:
      goto <D.18605>;
      <D.18604>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.44 = bitmap_data;
          bitmap_data = bitmap_data.44 + 8;
          _bmap = *bitmap_data.44;
          start_run = _objptr;
          goto <D.18599>;
          <D.18598>:
          D.19294 = _bmap & 1;
          if (D.19294 != 0) goto <D.19295>; else goto <D.19296>;
          <D.19295>:
          {
            void * __old;

            __old = *_objptr;
            if (__old != 0B) goto <D.19297>; else goto <D.19298>;
            <D.19297>:
            split_nursery_serial_copy_object_from_obj (_objptr, queue);
            if (0 != 0) goto <D.19299>; else goto <D.19300>;
            <D.19299>:
            D.19301 = *_objptr;
            if (D.19301 != __old) goto <D.19302>; else goto <D.19303>;
            <D.19302>:
            gc_debug_file.38 = gc_debug_file;
            D.19301 = *_objptr;
            fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19301, __old);
            gc_debug_file.38 = gc_debug_file;
            fflush (gc_debug_file.38);
            <D.19303>:
            <D.19300>:
            <D.19298>:
          }
          <D.19296>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18599>:
          if (_bmap != 0) goto <D.18598>; else goto <D.18600>;
          <D.18600>:
          _objptr = start_run + 512;
        }
        <D.18602>:
        bwords.45 = bwords;
        bwords = bwords.45 + 4294967295;
        if (bwords.45 != 0) goto <D.18601>; else goto <D.18603>;
        <D.18603>:
        D.19305 = (sizetype) el_size;
        e_start = e_start + D.19305;
      }
      <D.18605>:
      if (e_start < e_end) goto <D.18604>; else goto <D.18606>;
      <D.18606>:
    }
    goto <D.18521>;
    <D.18607>:
    goto <D.18521>;
    <D.18608>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.18521>:
  }
}


split_nursery_parallel_scan_vtype (char * start, mword desc, struct SgenGrayQueue * queue)
{
  long unsigned int D.19307;
  long unsigned int D.19308;
  long unsigned int D.19311;
  long unsigned int D.19312;
  long unsigned int D.19313;
  long unsigned int D.19314;
  long unsigned int D.19315;
  long unsigned int D.19316;
  struct FILE * gc_debug_file.46;
  void * D.19324;
  int iftmp.47;
  int D.19328;
  int D.19330;
  _Bool D.19332;
  long int D.19333;
  long int D.19334;
  int iftmp.48;
  int D.19346;
  int D.19348;
  _Bool D.19350;
  long int D.19351;
  long int D.19352;
  long unsigned int D.19355;
  long unsigned int D.19356;
  int D.19357;
  void * D.19364;
  int iftmp.49;
  int D.19368;
  int D.19370;
  _Bool D.19372;
  long int D.19373;
  long int D.19374;
  long unsigned int D.19377;
  long unsigned int D.19378;
  int D.19379;
  int iftmp.50;
  int D.19389;
  int D.19391;
  _Bool D.19393;
  long int D.19394;
  long int D.19395;
  long unsigned int D.19398;
  long unsigned int D.19401;
  int D.19402;
  int D.19403;
  unsigned int D.19406;
  unsigned int el_size.51;
  unsigned int D.19408;
  sizetype D.19409;
  void * D.19416;
  int iftmp.52;
  int D.19420;
  int D.19422;
  _Bool D.19424;
  long int D.19425;
  long int D.19426;
  int D.19432;
  int D.19433;
  long unsigned int D.19434;
  long unsigned int D.19435;
  long unsigned int D.19436;
  long unsigned int D.19437;
  void * * D.19438;
  void * D.19445;
  int iftmp.53;
  int D.19449;
  int D.19451;
  _Bool D.19453;
  long int D.19454;
  long int D.19455;
  sizetype D.19458;
  long unsigned int D.19462;
  void * D.19471;
  int iftmp.54;
  int D.19475;
  int D.19477;
  _Bool D.19479;
  long int D.19480;
  long int D.19481;
  long unsigned int D.19484;
  void * D.19493;
  int iftmp.55;
  int D.19497;
  int D.19499;
  _Bool D.19501;
  long int D.19502;
  long int D.19503;
  long unsigned int D.19506;
  unsigned int D.19507;
  unsigned int D.19508;
  struct MonoVTable * D.19511;
  struct MonoClass * D.19512;
  const char * D.19513;
  const char * D.19514;
  gsize * bitmap_data.56;
  long unsigned int D.19516;
  void * D.19525;
  int iftmp.57;
  int D.19529;
  int D.19531;
  _Bool D.19533;
  long int D.19534;
  long int D.19535;
  int bwords.58;

  start = start + 18446744073709551600;
  D.19307 = desc & 7;
  switch (D.19307) <default: <D.18506>, case 1: <D.18423>, case 2: <D.18434>, case 3: <D.18490>, case 4: <D.18446>, case 5: <D.18482>, case 7: <D.18505>>
  <D.18423>:
  D.19308 = desc & 4294901760;
  if (D.19308 != 0) goto <D.19309>; else goto <D.19310>;
  <D.19309>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.19311 = desc >> 16;
    D.19312 = D.19311 & 255;
    D.19313 = D.19312 * 8;
    _objptr = _objptr + D.19313;
    D.19314 = desc >> 24;
    D.19315 = D.19314 & 255;
    D.19316 = D.19315 * 8;
    _objptr_end = _objptr + D.19316;
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.19317>; else goto <D.19318>;
      <D.19317>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.19319>; else goto <D.19320>;
      <D.19319>:
      if (__old != __copy) goto <D.19321>; else goto <D.19322>;
      <D.19321>:
      gc_debug_file.46 = gc_debug_file;
      D.19324 = *_objptr;
      fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19324, __old);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19322>:
      <D.19320>:
      D.19328 = sgen_ptr_in_nursery (__copy);
      if (D.19328 != 0) goto <D.19329>; else goto <D.19326>;
      <D.19329>:
      D.19330 = sgen_ptr_in_nursery (_objptr);
      if (D.19330 == 0) goto <D.19331>; else goto <D.19326>;
      <D.19331>:
      iftmp.47 = 1;
      goto <D.19327>;
      <D.19326>:
      iftmp.47 = 0;
      <D.19327>:
      D.19332 = iftmp.47 != 0;
      D.19333 = (long int) D.19332;
      D.19334 = __builtin_expect (D.19333, 0);
      if (D.19334 != 0) goto <D.19335>; else goto <D.19336>;
      <D.19335>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.19336>:
      <D.19318>:
    }
    _objptr = _objptr + 8;
    goto <D.18431>;
    <D.18430>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.19337>; else goto <D.19338>;
      <D.19337>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.19339>; else goto <D.19340>;
      <D.19339>:
      if (__old != __copy) goto <D.19341>; else goto <D.19342>;
      <D.19341>:
      gc_debug_file.46 = gc_debug_file;
      D.19324 = *_objptr;
      fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19324, __old);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19342>:
      <D.19340>:
      D.19346 = sgen_ptr_in_nursery (__copy);
      if (D.19346 != 0) goto <D.19347>; else goto <D.19344>;
      <D.19347>:
      D.19348 = sgen_ptr_in_nursery (_objptr);
      if (D.19348 == 0) goto <D.19349>; else goto <D.19344>;
      <D.19349>:
      iftmp.48 = 1;
      goto <D.19345>;
      <D.19344>:
      iftmp.48 = 0;
      <D.19345>:
      D.19350 = iftmp.48 != 0;
      D.19351 = (long int) D.19350;
      D.19352 = __builtin_expect (D.19351, 0);
      if (D.19352 != 0) goto <D.19353>; else goto <D.19354>;
      <D.19353>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.19354>:
      <D.19338>:
    }
    _objptr = _objptr + 8;
    <D.18431>:
    if (_objptr < _objptr_end) goto <D.18430>; else goto <D.18432>;
    <D.18432>:
  }
  <D.19310>:
  goto <D.18433>;
  <D.18434>:
  {
    void * * _objptr;
    gsize _bmap;

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

      _index = __builtin_ctzl (_bmap);
      D.19355 = (long unsigned int) _index;
      D.19356 = D.19355 * 8;
      _objptr = _objptr + D.19356;
      D.19357 = _index + 1;
      _bmap = _bmap >> D.19357;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19358>; else goto <D.19359>;
        <D.19358>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19360>; else goto <D.19361>;
        <D.19360>:
        if (__old != __copy) goto <D.19362>; else goto <D.19363>;
        <D.19362>:
        gc_debug_file.46 = gc_debug_file;
        D.19364 = *_objptr;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19364, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19363>:
        <D.19361>:
        D.19368 = sgen_ptr_in_nursery (__copy);
        if (D.19368 != 0) goto <D.19369>; else goto <D.19366>;
        <D.19369>:
        D.19370 = sgen_ptr_in_nursery (_objptr);
        if (D.19370 == 0) goto <D.19371>; else goto <D.19366>;
        <D.19371>:
        iftmp.49 = 1;
        goto <D.19367>;
        <D.19366>:
        iftmp.49 = 0;
        <D.19367>:
        D.19372 = iftmp.49 != 0;
        D.19373 = (long int) D.19372;
        D.19374 = __builtin_expect (D.19373, 0);
        if (D.19374 != 0) goto <D.19375>; else goto <D.19376>;
        <D.19375>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19376>:
        <D.19359>:
      }
      _objptr = _objptr + 8;
    }
    goto <D.18444>;
    <D.18443>:
    {
      int _index;

      _index = __builtin_ctzl (_bmap);
      D.19377 = (long unsigned int) _index;
      D.19378 = D.19377 * 8;
      _objptr = _objptr + D.19378;
      D.19379 = _index + 1;
      _bmap = _bmap >> D.19379;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19380>; else goto <D.19381>;
        <D.19380>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19382>; else goto <D.19383>;
        <D.19382>:
        if (__old != __copy) goto <D.19384>; else goto <D.19385>;
        <D.19384>:
        gc_debug_file.46 = gc_debug_file;
        D.19364 = *_objptr;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19364, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19385>:
        <D.19383>:
        D.19389 = sgen_ptr_in_nursery (__copy);
        if (D.19389 != 0) goto <D.19390>; else goto <D.19387>;
        <D.19390>:
        D.19391 = sgen_ptr_in_nursery (_objptr);
        if (D.19391 == 0) goto <D.19392>; else goto <D.19387>;
        <D.19392>:
        iftmp.50 = 1;
        goto <D.19388>;
        <D.19387>:
        iftmp.50 = 0;
        <D.19388>:
        D.19393 = iftmp.50 != 0;
        D.19394 = (long int) D.19393;
        D.19395 = __builtin_expect (D.19394, 0);
        if (D.19395 != 0) goto <D.19396>; else goto <D.19397>;
        <D.19396>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19397>:
        <D.19381>:
      }
      _objptr = _objptr + 8;
    }
    <D.18444>:
    if (_bmap != 0) goto <D.18443>; else goto <D.18445>;
    <D.18445>:
  }
  goto <D.18433>;
  <D.18446>:
  D.19398 = desc & 4294950912;
  if (D.19398 != 0) goto <D.19399>; else goto <D.19400>;
  <D.19399>:
  {
    int el_size;
    int etype;

    D.19401 = desc >> 3;
    D.19402 = (int) D.19401;
    el_size = D.19402 & 1023;
    D.19403 = (int) desc;
    etype = D.19403 & 49152;
    if (etype == 16384) goto <D.19404>; else goto <D.19405>;
    <D.19404>:
    {
      void * * p;
      void * * end_refs;

      p = start + 32;
      D.19406 = MEM[(struct MonoArray *)start].max_length;
      el_size.51 = (unsigned int) el_size;
      D.19408 = D.19406 * el_size.51;
      D.19409 = (sizetype) D.19408;
      end_refs = p + D.19409;
      goto <D.18454>;
      <D.18453>:
      {
        void * __old;
        void * __copy;

        __old = *p;
        if (__old != 0B) goto <D.19410>; else goto <D.19411>;
        <D.19410>:
        split_nursery_parallel_copy_object (p, queue);
        __copy = *p;
        if (0 != 0) goto <D.19412>; else goto <D.19413>;
        <D.19412>:
        if (__old != __copy) goto <D.19414>; else goto <D.19415>;
        <D.19414>:
        gc_debug_file.46 = gc_debug_file;
        D.19416 = *p;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", p, D.19416, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19415>:
        <D.19413>:
        D.19420 = sgen_ptr_in_nursery (__copy);
        if (D.19420 != 0) goto <D.19421>; else goto <D.19418>;
        <D.19421>:
        D.19422 = sgen_ptr_in_nursery (p);
        if (D.19422 == 0) goto <D.19423>; else goto <D.19418>;
        <D.19423>:
        iftmp.52 = 1;
        goto <D.19419>;
        <D.19418>:
        iftmp.52 = 0;
        <D.19419>:
        D.19424 = iftmp.52 != 0;
        D.19425 = (long int) D.19424;
        D.19426 = __builtin_expect (D.19425, 0);
        if (D.19426 != 0) goto <D.19427>; else goto <D.19428>;
        <D.19427>:
        sgen_add_to_global_remset (p, __copy);
        <D.19428>:
        <D.19411>:
      }
      p = p + 8;
      <D.18454>:
      if (p < end_refs) goto <D.18453>; else goto <D.18455>;
      <D.18455>:
    }
    goto <D.19429>;
    <D.19405>:
    if (etype == 32768) goto <D.19430>; else goto <D.19431>;
    <D.19430>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.19311 = desc >> 16;
      D.19432 = (int) D.19311;
      offset = D.19432 & 255;
      D.19314 = desc >> 24;
      D.19433 = (int) D.19314;
      num_refs = D.19433 & 255;
      e_start = start + 32;
      D.19406 = MEM[(struct MonoArray *)start].max_length;
      el_size.51 = (unsigned int) el_size;
      D.19408 = D.19406 * el_size.51;
      D.19409 = (sizetype) D.19408;
      e_end = e_start + D.19409;
      goto <D.18468>;
      <D.18467>:
      {
        void * * p;
        int i;

        p = e_start;
        D.19434 = (long unsigned int) offset;
        D.19435 = D.19434 * 8;
        p = p + D.19435;
        i = 0;
        goto <D.18465>;
        <D.18464>:
        {
          void * __old;
          void * __copy;

          D.19436 = (long unsigned int) i;
          D.19437 = D.19436 * 8;
          D.19438 = p + D.19437;
          __old = *D.19438;
          if (__old != 0B) goto <D.19439>; else goto <D.19440>;
          <D.19439>:
          D.19436 = (long unsigned int) i;
          D.19437 = D.19436 * 8;
          D.19438 = p + D.19437;
          split_nursery_parallel_copy_object (D.19438, queue);
          D.19436 = (long unsigned int) i;
          D.19437 = D.19436 * 8;
          D.19438 = p + D.19437;
          __copy = *D.19438;
          if (0 != 0) goto <D.19441>; else goto <D.19442>;
          <D.19441>:
          if (__old != __copy) goto <D.19443>; else goto <D.19444>;
          <D.19443>:
          gc_debug_file.46 = gc_debug_file;
          D.19436 = (long unsigned int) i;
          D.19437 = D.19436 * 8;
          D.19438 = p + D.19437;
          D.19436 = (long unsigned int) i;
          D.19437 = D.19436 * 8;
          D.19438 = p + D.19437;
          D.19445 = *D.19438;
          fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", D.19438, D.19445, __old);
          gc_debug_file.46 = gc_debug_file;
          fflush (gc_debug_file.46);
          <D.19444>:
          <D.19442>:
          D.19449 = sgen_ptr_in_nursery (__copy);
          if (D.19449 != 0) goto <D.19450>; else goto <D.19447>;
          <D.19450>:
          D.19436 = (long unsigned int) i;
          D.19437 = D.19436 * 8;
          D.19438 = p + D.19437;
          D.19451 = sgen_ptr_in_nursery (D.19438);
          if (D.19451 == 0) goto <D.19452>; else goto <D.19447>;
          <D.19452>:
          iftmp.53 = 1;
          goto <D.19448>;
          <D.19447>:
          iftmp.53 = 0;
          <D.19448>:
          D.19453 = iftmp.53 != 0;
          D.19454 = (long int) D.19453;
          D.19455 = __builtin_expect (D.19454, 0);
          if (D.19455 != 0) goto <D.19456>; else goto <D.19457>;
          <D.19456>:
          D.19436 = (long unsigned int) i;
          D.19437 = D.19436 * 8;
          D.19438 = p + D.19437;
          sgen_add_to_global_remset (D.19438, __copy);
          <D.19457>:
          <D.19440>:
        }
        i = i + 1;
        <D.18465>:
        if (i < num_refs) goto <D.18464>; else goto <D.18466>;
        <D.18466>:
        D.19458 = (sizetype) el_size;
        e_start = e_start + D.19458;
      }
      <D.18468>:
      if (e_start < e_end) goto <D.18467>; else goto <D.18469>;
      <D.18469>:
    }
    goto <D.19459>;
    <D.19431>:
    if (etype == 49152) goto <D.19460>; else goto <D.19461>;
    <D.19460>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 32;
      D.19406 = MEM[(struct MonoArray *)start].max_length;
      el_size.51 = (unsigned int) el_size;
      D.19408 = D.19406 * el_size.51;
      D.19409 = (sizetype) D.19408;
      e_end = e_start + D.19409;
      goto <D.18480>;
      <D.18479>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.18477>;
        <D.18476>:
        D.19462 = _bmap & 1;
        if (D.19462 != 0) goto <D.19463>; else goto <D.19464>;
        <D.19463>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.19465>; else goto <D.19466>;
          <D.19465>:
          split_nursery_parallel_copy_object (p, queue);
          __copy = *p;
          if (0 != 0) goto <D.19467>; else goto <D.19468>;
          <D.19467>:
          if (__old != __copy) goto <D.19469>; else goto <D.19470>;
          <D.19469>:
          gc_debug_file.46 = gc_debug_file;
          D.19471 = *p;
          fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", p, D.19471, __old);
          gc_debug_file.46 = gc_debug_file;
          fflush (gc_debug_file.46);
          <D.19470>:
          <D.19468>:
          D.19475 = sgen_ptr_in_nursery (__copy);
          if (D.19475 != 0) goto <D.19476>; else goto <D.19473>;
          <D.19476>:
          D.19477 = sgen_ptr_in_nursery (p);
          if (D.19477 == 0) goto <D.19478>; else goto <D.19473>;
          <D.19478>:
          iftmp.54 = 1;
          goto <D.19474>;
          <D.19473>:
          iftmp.54 = 0;
          <D.19474>:
          D.19479 = iftmp.54 != 0;
          D.19480 = (long int) D.19479;
          D.19481 = __builtin_expect (D.19480, 0);
          if (D.19481 != 0) goto <D.19482>; else goto <D.19483>;
          <D.19482>:
          sgen_add_to_global_remset (p, __copy);
          <D.19483>:
          <D.19466>:
        }
        <D.19464>:
        _bmap = _bmap >> 1;
        p = p + 8;
        <D.18477>:
        if (_bmap != 0) goto <D.18476>; else goto <D.18478>;
        <D.18478>:
        D.19458 = (sizetype) el_size;
        e_start = e_start + D.19458;
      }
      <D.18480>:
      if (e_start < e_end) goto <D.18479>; else goto <D.18481>;
      <D.18481>:
    }
    <D.19461>:
    <D.19459>:
    <D.19429>:
  }
  <D.19400>:
  goto <D.18433>;
  <D.18482>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 3;
    _objptr = _objptr + 16;
    goto <D.18488>;
    <D.18487>:
    D.19484 = _bmap & 1;
    if (D.19484 != 0) goto <D.19485>; else goto <D.19486>;
    <D.19485>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.19487>; else goto <D.19488>;
      <D.19487>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.19489>; else goto <D.19490>;
      <D.19489>:
      if (__old != __copy) goto <D.19491>; else goto <D.19492>;
      <D.19491>:
      gc_debug_file.46 = gc_debug_file;
      D.19493 = *_objptr;
      fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19493, __old);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19492>:
      <D.19490>:
      D.19497 = sgen_ptr_in_nursery (__copy);
      if (D.19497 != 0) goto <D.19498>; else goto <D.19495>;
      <D.19498>:
      D.19499 = sgen_ptr_in_nursery (_objptr);
      if (D.19499 == 0) goto <D.19500>; else goto <D.19495>;
      <D.19500>:
      iftmp.55 = 1;
      goto <D.19496>;
      <D.19495>:
      iftmp.55 = 0;
      <D.19496>:
      D.19501 = iftmp.55 != 0;
      D.19502 = (long int) D.19501;
      D.19503 = __builtin_expect (D.19502, 0);
      if (D.19503 != 0) goto <D.19504>; else goto <D.19505>;
      <D.19504>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.19505>:
      <D.19488>:
    }
    <D.19486>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 8;
    <D.18488>:
    if (_bmap != 0) goto <D.18487>; else goto <D.18489>;
    <D.18489>:
  }
  goto <D.18433>;
  <D.18490>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.19506 = *bitmap_data;
    D.19507 = (unsigned int) D.19506;
    D.19508 = D.19507 + 4294967295;
    bwords = (int) D.19508;
    start_run = _objptr;
    bitmap_data = bitmap_data + 8;
    if (0 != 0) goto <D.19509>; else goto <D.19510>;
    <D.19509>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.19511 = myobj->vtable;
      D.19512 = D.19511->klass;
      D.19513 = D.19512->name_space;
      D.19511 = myobj->vtable;
      D.19512 = D.19511->klass;
      D.19514 = D.19512->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19513, D.19514);
    }
    <D.19510>:
    goto <D.18503>;
    <D.18502>:
    {
      gsize _bmap;

      bitmap_data.56 = bitmap_data;
      bitmap_data = bitmap_data.56 + 8;
      _bmap = *bitmap_data.56;
      _objptr = start_run;
      goto <D.18500>;
      <D.18499>:
      D.19516 = _bmap & 1;
      if (D.19516 != 0) goto <D.19517>; else goto <D.19518>;
      <D.19517>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19519>; else goto <D.19520>;
        <D.19519>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19521>; else goto <D.19522>;
        <D.19521>:
        if (__old != __copy) goto <D.19523>; else goto <D.19524>;
        <D.19523>:
        gc_debug_file.46 = gc_debug_file;
        D.19525 = *_objptr;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19525, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19524>:
        <D.19522>:
        D.19529 = sgen_ptr_in_nursery (__copy);
        if (D.19529 != 0) goto <D.19530>; else goto <D.19527>;
        <D.19530>:
        D.19531 = sgen_ptr_in_nursery (_objptr);
        if (D.19531 == 0) goto <D.19532>; else goto <D.19527>;
        <D.19532>:
        iftmp.57 = 1;
        goto <D.19528>;
        <D.19527>:
        iftmp.57 = 0;
        <D.19528>:
        D.19533 = iftmp.57 != 0;
        D.19534 = (long int) D.19533;
        D.19535 = __builtin_expect (D.19534, 0);
        if (D.19535 != 0) goto <D.19536>; else goto <D.19537>;
        <D.19536>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19537>:
        <D.19520>:
      }
      <D.19518>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18500>:
      if (_bmap != 0) goto <D.18499>; else goto <D.18501>;
      <D.18501>:
      start_run = start_run + 512;
    }
    <D.18503>:
    bwords.58 = bwords;
    bwords = bwords.58 + -1;
    if (bwords.58 > 0) goto <D.18502>; else goto <D.18504>;
    <D.18504>:
  }
  goto <D.18433>;
  <D.18505>:
  goto <D.18433>;
  <D.18506>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.18433>:
}


split_nursery_parallel_scan_object (char * start, struct SgenGrayQueue * queue)
{
  long unsigned int D.19540;
  long unsigned int D.19541;
  long unsigned int D.19542;
  long unsigned int D.19543;
  long unsigned int D.19546;
  long unsigned int D.19547;
  long unsigned int D.19548;
  long unsigned int D.19549;
  long unsigned int D.19550;
  long unsigned int D.19551;
  struct FILE * gc_debug_file.59;
  void * D.19559;
  int iftmp.60;
  int D.19563;
  int D.19565;
  _Bool D.19567;
  long int D.19568;
  long int D.19569;
  int iftmp.61;
  int D.19581;
  int D.19583;
  _Bool D.19585;
  long int D.19586;
  long int D.19587;
  long unsigned int D.19590;
  long unsigned int D.19591;
  int D.19592;
  void * D.19599;
  int iftmp.62;
  int D.19603;
  int D.19605;
  _Bool D.19607;
  long int D.19608;
  long int D.19609;
  long unsigned int D.19612;
  long unsigned int D.19613;
  int D.19614;
  int iftmp.63;
  int D.19624;
  int D.19626;
  _Bool D.19628;
  long int D.19629;
  long int D.19630;
  long unsigned int D.19633;
  long unsigned int D.19636;
  int D.19637;
  int D.19638;
  unsigned int D.19641;
  unsigned int el_size.64;
  unsigned int D.19643;
  sizetype D.19644;
  void * D.19651;
  int iftmp.65;
  int D.19655;
  int D.19657;
  _Bool D.19659;
  long int D.19660;
  long int D.19661;
  int D.19667;
  int D.19668;
  long unsigned int D.19669;
  long unsigned int D.19670;
  long unsigned int D.19671;
  long unsigned int D.19672;
  void * * D.19673;
  void * D.19680;
  int iftmp.66;
  int D.19684;
  int D.19686;
  _Bool D.19688;
  long int D.19689;
  long int D.19690;
  sizetype D.19693;
  long unsigned int D.19697;
  void * D.19706;
  int iftmp.67;
  int D.19710;
  int D.19712;
  _Bool D.19714;
  long int D.19715;
  long int D.19716;
  long unsigned int D.19719;
  void * D.19728;
  int iftmp.68;
  int D.19732;
  int D.19734;
  _Bool D.19736;
  long int D.19737;
  long int D.19738;
  long unsigned int D.19741;
  unsigned int D.19742;
  unsigned int D.19743;
  struct MonoVTable * D.19746;
  struct MonoClass * D.19747;
  const char * D.19748;
  const char * D.19749;
  gsize * bitmap_data.69;
  long unsigned int D.19751;
  void * D.19760;
  int iftmp.70;
  int D.19764;
  int D.19766;
  _Bool D.19768;
  long int D.19769;
  long int D.19770;
  int bwords.71;
  long unsigned int D.19774;
  gsize * mbitmap_data.72;
  long unsigned int D.19776;
  unsigned int D.19777;
  unsigned int D.19778;
  struct MonoClass * D.19779;
  unsigned int el_size.73;
  unsigned int D.19781;
  sizetype D.19782;
  const char * D.19785;
  const char * D.19786;
  gsize * bitmap_data.74;
  long unsigned int D.19788;
  void * D.19797;
  int iftmp.75;
  int D.19801;
  int D.19803;
  _Bool D.19805;
  long int D.19806;
  long int D.19807;
  unsigned int bwords.76;
  sizetype D.19811;

  {
    struct GCVTable * vt;
    mword desc;

    D.19540 = MEM[(mword *)start];
    D.19541 = D.19540 & 18446744073709551612;
    vt = (struct GCVTable *) D.19541;
    desc = vt->desc;
    D.19542 = desc & 7;
    switch (D.19542) <default: <D.18417>, case 1: <D.18312>, case 2: <D.18323>, case 3: <D.18379>, case 4: <D.18335>, case 5: <D.18371>, case 6: <D.18394>, case 7: <D.18416>>
    <D.18312>:
    D.19543 = desc & 4294901760;
    if (D.19543 != 0) goto <D.19544>; else goto <D.19545>;
    <D.19544>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19546 = desc >> 16;
      D.19547 = D.19546 & 255;
      D.19548 = D.19547 * 8;
      _objptr = _objptr + D.19548;
      D.19549 = desc >> 24;
      D.19550 = D.19549 & 255;
      D.19551 = D.19550 * 8;
      _objptr_end = _objptr + D.19551;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19552>; else goto <D.19553>;
        <D.19552>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19554>; else goto <D.19555>;
        <D.19554>:
        if (__old != __copy) goto <D.19556>; else goto <D.19557>;
        <D.19556>:
        gc_debug_file.59 = gc_debug_file;
        D.19559 = *_objptr;
        fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19559, __old);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.19557>:
        <D.19555>:
        D.19563 = sgen_ptr_in_nursery (__copy);
        if (D.19563 != 0) goto <D.19564>; else goto <D.19561>;
        <D.19564>:
        D.19565 = sgen_ptr_in_nursery (_objptr);
        if (D.19565 == 0) goto <D.19566>; else goto <D.19561>;
        <D.19566>:
        iftmp.60 = 1;
        goto <D.19562>;
        <D.19561>:
        iftmp.60 = 0;
        <D.19562>:
        D.19567 = iftmp.60 != 0;
        D.19568 = (long int) D.19567;
        D.19569 = __builtin_expect (D.19568, 0);
        if (D.19569 != 0) goto <D.19570>; else goto <D.19571>;
        <D.19570>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19571>:
        <D.19553>:
      }
      _objptr = _objptr + 8;
      goto <D.18320>;
      <D.18319>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19572>; else goto <D.19573>;
        <D.19572>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19574>; else goto <D.19575>;
        <D.19574>:
        if (__old != __copy) goto <D.19576>; else goto <D.19577>;
        <D.19576>:
        gc_debug_file.59 = gc_debug_file;
        D.19559 = *_objptr;
        fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19559, __old);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.19577>:
        <D.19575>:
        D.19581 = sgen_ptr_in_nursery (__copy);
        if (D.19581 != 0) goto <D.19582>; else goto <D.19579>;
        <D.19582>:
        D.19583 = sgen_ptr_in_nursery (_objptr);
        if (D.19583 == 0) goto <D.19584>; else goto <D.19579>;
        <D.19584>:
        iftmp.61 = 1;
        goto <D.19580>;
        <D.19579>:
        iftmp.61 = 0;
        <D.19580>:
        D.19585 = iftmp.61 != 0;
        D.19586 = (long int) D.19585;
        D.19587 = __builtin_expect (D.19586, 0);
        if (D.19587 != 0) goto <D.19588>; else goto <D.19589>;
        <D.19588>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19589>:
        <D.19573>:
      }
      _objptr = _objptr + 8;
      <D.18320>:
      if (_objptr < _objptr_end) goto <D.18319>; else goto <D.18321>;
      <D.18321>:
    }
    <D.19545>:
    goto <D.18322>;
    <D.18323>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.19590 = (long unsigned int) _index;
        D.19591 = D.19590 * 8;
        _objptr = _objptr + D.19591;
        D.19592 = _index + 1;
        _bmap = _bmap >> D.19592;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.19593>; else goto <D.19594>;
          <D.19593>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.19595>; else goto <D.19596>;
          <D.19595>:
          if (__old != __copy) goto <D.19597>; else goto <D.19598>;
          <D.19597>:
          gc_debug_file.59 = gc_debug_file;
          D.19599 = *_objptr;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19599, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.19598>:
          <D.19596>:
          D.19603 = sgen_ptr_in_nursery (__copy);
          if (D.19603 != 0) goto <D.19604>; else goto <D.19601>;
          <D.19604>:
          D.19605 = sgen_ptr_in_nursery (_objptr);
          if (D.19605 == 0) goto <D.19606>; else goto <D.19601>;
          <D.19606>:
          iftmp.62 = 1;
          goto <D.19602>;
          <D.19601>:
          iftmp.62 = 0;
          <D.19602>:
          D.19607 = iftmp.62 != 0;
          D.19608 = (long int) D.19607;
          D.19609 = __builtin_expect (D.19608, 0);
          if (D.19609 != 0) goto <D.19610>; else goto <D.19611>;
          <D.19610>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.19611>:
          <D.19594>:
        }
        _objptr = _objptr + 8;
      }
      goto <D.18333>;
      <D.18332>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.19612 = (long unsigned int) _index;
        D.19613 = D.19612 * 8;
        _objptr = _objptr + D.19613;
        D.19614 = _index + 1;
        _bmap = _bmap >> D.19614;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.19615>; else goto <D.19616>;
          <D.19615>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.19617>; else goto <D.19618>;
          <D.19617>:
          if (__old != __copy) goto <D.19619>; else goto <D.19620>;
          <D.19619>:
          gc_debug_file.59 = gc_debug_file;
          D.19599 = *_objptr;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19599, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.19620>:
          <D.19618>:
          D.19624 = sgen_ptr_in_nursery (__copy);
          if (D.19624 != 0) goto <D.19625>; else goto <D.19622>;
          <D.19625>:
          D.19626 = sgen_ptr_in_nursery (_objptr);
          if (D.19626 == 0) goto <D.19627>; else goto <D.19622>;
          <D.19627>:
          iftmp.63 = 1;
          goto <D.19623>;
          <D.19622>:
          iftmp.63 = 0;
          <D.19623>:
          D.19628 = iftmp.63 != 0;
          D.19629 = (long int) D.19628;
          D.19630 = __builtin_expect (D.19629, 0);
          if (D.19630 != 0) goto <D.19631>; else goto <D.19632>;
          <D.19631>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.19632>:
          <D.19616>:
        }
        _objptr = _objptr + 8;
      }
      <D.18333>:
      if (_bmap != 0) goto <D.18332>; else goto <D.18334>;
      <D.18334>:
    }
    goto <D.18322>;
    <D.18335>:
    D.19633 = desc & 4294950912;
    if (D.19633 != 0) goto <D.19634>; else goto <D.19635>;
    <D.19634>:
    {
      int el_size;
      int etype;

      D.19636 = desc >> 3;
      D.19637 = (int) D.19636;
      el_size = D.19637 & 1023;
      D.19638 = (int) desc;
      etype = D.19638 & 49152;
      if (etype == 16384) goto <D.19639>; else goto <D.19640>;
      <D.19639>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.19641 = MEM[(struct MonoArray *)start].max_length;
        el_size.64 = (unsigned int) el_size;
        D.19643 = D.19641 * el_size.64;
        D.19644 = (sizetype) D.19643;
        end_refs = p + D.19644;
        goto <D.18343>;
        <D.18342>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.19645>; else goto <D.19646>;
          <D.19645>:
          split_nursery_parallel_copy_object (p, queue);
          __copy = *p;
          if (0 != 0) goto <D.19647>; else goto <D.19648>;
          <D.19647>:
          if (__old != __copy) goto <D.19649>; else goto <D.19650>;
          <D.19649>:
          gc_debug_file.59 = gc_debug_file;
          D.19651 = *p;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", p, D.19651, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.19650>:
          <D.19648>:
          D.19655 = sgen_ptr_in_nursery (__copy);
          if (D.19655 != 0) goto <D.19656>; else goto <D.19653>;
          <D.19656>:
          D.19657 = sgen_ptr_in_nursery (p);
          if (D.19657 == 0) goto <D.19658>; else goto <D.19653>;
          <D.19658>:
          iftmp.65 = 1;
          goto <D.19654>;
          <D.19653>:
          iftmp.65 = 0;
          <D.19654>:
          D.19659 = iftmp.65 != 0;
          D.19660 = (long int) D.19659;
          D.19661 = __builtin_expect (D.19660, 0);
          if (D.19661 != 0) goto <D.19662>; else goto <D.19663>;
          <D.19662>:
          sgen_add_to_global_remset (p, __copy);
          <D.19663>:
          <D.19646>:
        }
        p = p + 8;
        <D.18343>:
        if (p < end_refs) goto <D.18342>; else goto <D.18344>;
        <D.18344>:
      }
      goto <D.19664>;
      <D.19640>:
      if (etype == 32768) goto <D.19665>; else goto <D.19666>;
      <D.19665>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19546 = desc >> 16;
        D.19667 = (int) D.19546;
        offset = D.19667 & 255;
        D.19549 = desc >> 24;
        D.19668 = (int) D.19549;
        num_refs = D.19668 & 255;
        e_start = start + 32;
        D.19641 = MEM[(struct MonoArray *)start].max_length;
        el_size.64 = (unsigned int) el_size;
        D.19643 = D.19641 * el_size.64;
        D.19644 = (sizetype) D.19643;
        e_end = e_start + D.19644;
        goto <D.18357>;
        <D.18356>:
        {
          void * * p;
          int i;

          p = e_start;
          D.19669 = (long unsigned int) offset;
          D.19670 = D.19669 * 8;
          p = p + D.19670;
          i = 0;
          goto <D.18354>;
          <D.18353>:
          {
            void * __old;
            void * __copy;

            D.19671 = (long unsigned int) i;
            D.19672 = D.19671 * 8;
            D.19673 = p + D.19672;
            __old = *D.19673;
            if (__old != 0B) goto <D.19674>; else goto <D.19675>;
            <D.19674>:
            D.19671 = (long unsigned int) i;
            D.19672 = D.19671 * 8;
            D.19673 = p + D.19672;
            split_nursery_parallel_copy_object (D.19673, queue);
            D.19671 = (long unsigned int) i;
            D.19672 = D.19671 * 8;
            D.19673 = p + D.19672;
            __copy = *D.19673;
            if (0 != 0) goto <D.19676>; else goto <D.19677>;
            <D.19676>:
            if (__old != __copy) goto <D.19678>; else goto <D.19679>;
            <D.19678>:
            gc_debug_file.59 = gc_debug_file;
            D.19671 = (long unsigned int) i;
            D.19672 = D.19671 * 8;
            D.19673 = p + D.19672;
            D.19671 = (long unsigned int) i;
            D.19672 = D.19671 * 8;
            D.19673 = p + D.19672;
            D.19680 = *D.19673;
            fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", D.19673, D.19680, __old);
            gc_debug_file.59 = gc_debug_file;
            fflush (gc_debug_file.59);
            <D.19679>:
            <D.19677>:
            D.19684 = sgen_ptr_in_nursery (__copy);
            if (D.19684 != 0) goto <D.19685>; else goto <D.19682>;
            <D.19685>:
            D.19671 = (long unsigned int) i;
            D.19672 = D.19671 * 8;
            D.19673 = p + D.19672;
            D.19686 = sgen_ptr_in_nursery (D.19673);
            if (D.19686 == 0) goto <D.19687>; else goto <D.19682>;
            <D.19687>:
            iftmp.66 = 1;
            goto <D.19683>;
            <D.19682>:
            iftmp.66 = 0;
            <D.19683>:
            D.19688 = iftmp.66 != 0;
            D.19689 = (long int) D.19688;
            D.19690 = __builtin_expect (D.19689, 0);
            if (D.19690 != 0) goto <D.19691>; else goto <D.19692>;
            <D.19691>:
            D.19671 = (long unsigned int) i;
            D.19672 = D.19671 * 8;
            D.19673 = p + D.19672;
            sgen_add_to_global_remset (D.19673, __copy);
            <D.19692>:
            <D.19675>:
          }
          i = i + 1;
          <D.18354>:
          if (i < num_refs) goto <D.18353>; else goto <D.18355>;
          <D.18355>:
          D.19693 = (sizetype) el_size;
          e_start = e_start + D.19693;
        }
        <D.18357>:
        if (e_start < e_end) goto <D.18356>; else goto <D.18358>;
        <D.18358>:
      }
      goto <D.19694>;
      <D.19666>:
      if (etype == 49152) goto <D.19695>; else goto <D.19696>;
      <D.19695>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.19641 = MEM[(struct MonoArray *)start].max_length;
        el_size.64 = (unsigned int) el_size;
        D.19643 = D.19641 * el_size.64;
        D.19644 = (sizetype) D.19643;
        e_end = e_start + D.19644;
        goto <D.18369>;
        <D.18368>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.18366>;
          <D.18365>:
          D.19697 = _bmap & 1;
          if (D.19697 != 0) goto <D.19698>; else goto <D.19699>;
          <D.19698>:
          {
            void * __old;
            void * __copy;

            __old = *p;
            if (__old != 0B) goto <D.19700>; else goto <D.19701>;
            <D.19700>:
            split_nursery_parallel_copy_object (p, queue);
            __copy = *p;
            if (0 != 0) goto <D.19702>; else goto <D.19703>;
            <D.19702>:
            if (__old != __copy) goto <D.19704>; else goto <D.19705>;
            <D.19704>:
            gc_debug_file.59 = gc_debug_file;
            D.19706 = *p;
            fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", p, D.19706, __old);
            gc_debug_file.59 = gc_debug_file;
            fflush (gc_debug_file.59);
            <D.19705>:
            <D.19703>:
            D.19710 = sgen_ptr_in_nursery (__copy);
            if (D.19710 != 0) goto <D.19711>; else goto <D.19708>;
            <D.19711>:
            D.19712 = sgen_ptr_in_nursery (p);
            if (D.19712 == 0) goto <D.19713>; else goto <D.19708>;
            <D.19713>:
            iftmp.67 = 1;
            goto <D.19709>;
            <D.19708>:
            iftmp.67 = 0;
            <D.19709>:
            D.19714 = iftmp.67 != 0;
            D.19715 = (long int) D.19714;
            D.19716 = __builtin_expect (D.19715, 0);
            if (D.19716 != 0) goto <D.19717>; else goto <D.19718>;
            <D.19717>:
            sgen_add_to_global_remset (p, __copy);
            <D.19718>:
            <D.19701>:
          }
          <D.19699>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.18366>:
          if (_bmap != 0) goto <D.18365>; else goto <D.18367>;
          <D.18367>:
          D.19693 = (sizetype) el_size;
          e_start = e_start + D.19693;
        }
        <D.18369>:
        if (e_start < e_end) goto <D.18368>; else goto <D.18370>;
        <D.18370>:
      }
      <D.19696>:
      <D.19694>:
      <D.19664>:
    }
    <D.19635>:
    goto <D.18322>;
    <D.18371>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.18377>;
      <D.18376>:
      D.19719 = _bmap & 1;
      if (D.19719 != 0) goto <D.19720>; else goto <D.19721>;
      <D.19720>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19722>; else goto <D.19723>;
        <D.19722>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19724>; else goto <D.19725>;
        <D.19724>:
        if (__old != __copy) goto <D.19726>; else goto <D.19727>;
        <D.19726>:
        gc_debug_file.59 = gc_debug_file;
        D.19728 = *_objptr;
        fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19728, __old);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.19727>:
        <D.19725>:
        D.19732 = sgen_ptr_in_nursery (__copy);
        if (D.19732 != 0) goto <D.19733>; else goto <D.19730>;
        <D.19733>:
        D.19734 = sgen_ptr_in_nursery (_objptr);
        if (D.19734 == 0) goto <D.19735>; else goto <D.19730>;
        <D.19735>:
        iftmp.68 = 1;
        goto <D.19731>;
        <D.19730>:
        iftmp.68 = 0;
        <D.19731>:
        D.19736 = iftmp.68 != 0;
        D.19737 = (long int) D.19736;
        D.19738 = __builtin_expect (D.19737, 0);
        if (D.19738 != 0) goto <D.19739>; else goto <D.19740>;
        <D.19739>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19740>:
        <D.19723>:
      }
      <D.19721>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18377>:
      if (_bmap != 0) goto <D.18376>; else goto <D.18378>;
      <D.18378>:
    }
    goto <D.18322>;
    <D.18379>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19741 = *bitmap_data;
      D.19742 = (unsigned int) D.19741;
      D.19743 = D.19742 + 4294967295;
      bwords = (int) D.19743;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.19744>; else goto <D.19745>;
      <D.19744>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19746 = myobj->vtable;
        D.19747 = D.19746->klass;
        D.19748 = D.19747->name_space;
        D.19746 = myobj->vtable;
        D.19747 = D.19746->klass;
        D.19749 = D.19747->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19748, D.19749);
      }
      <D.19745>:
      goto <D.18392>;
      <D.18391>:
      {
        gsize _bmap;

        bitmap_data.69 = bitmap_data;
        bitmap_data = bitmap_data.69 + 8;
        _bmap = *bitmap_data.69;
        _objptr = start_run;
        goto <D.18389>;
        <D.18388>:
        D.19751 = _bmap & 1;
        if (D.19751 != 0) goto <D.19752>; else goto <D.19753>;
        <D.19752>:
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.19754>; else goto <D.19755>;
          <D.19754>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.19756>; else goto <D.19757>;
          <D.19756>:
          if (__old != __copy) goto <D.19758>; else goto <D.19759>;
          <D.19758>:
          gc_debug_file.59 = gc_debug_file;
          D.19760 = *_objptr;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19760, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.19759>:
          <D.19757>:
          D.19764 = sgen_ptr_in_nursery (__copy);
          if (D.19764 != 0) goto <D.19765>; else goto <D.19762>;
          <D.19765>:
          D.19766 = sgen_ptr_in_nursery (_objptr);
          if (D.19766 == 0) goto <D.19767>; else goto <D.19762>;
          <D.19767>:
          iftmp.70 = 1;
          goto <D.19763>;
          <D.19762>:
          iftmp.70 = 0;
          <D.19763>:
          D.19768 = iftmp.70 != 0;
          D.19769 = (long int) D.19768;
          D.19770 = __builtin_expect (D.19769, 0);
          if (D.19770 != 0) goto <D.19771>; else goto <D.19772>;
          <D.19771>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.19772>:
          <D.19755>:
        }
        <D.19753>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18389>:
        if (_bmap != 0) goto <D.18388>; else goto <D.18390>;
        <D.18390>:
        start_run = start_run + 512;
      }
      <D.18392>:
      bwords.71 = bwords;
      bwords = bwords.71 + -1;
      if (bwords.71 > 0) goto <D.18391>; else goto <D.18393>;
      <D.18393>:
    }
    goto <D.18322>;
    <D.18394>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19774 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19774);
      mbitmap_data.72 = mbitmap_data;
      mbitmap_data = mbitmap_data.72 + 8;
      D.19776 = *mbitmap_data.72;
      D.19777 = (unsigned int) D.19776;
      D.19778 = D.19777 + 4294967295;
      mbwords = (int) D.19778;
      D.19779 = vt->klass;
      el_size = mono_array_element_size (D.19779);
      e_start = start + 32;
      D.19641 = MEM[(struct MonoArray *)start].max_length;
      el_size.73 = (unsigned int) el_size;
      D.19781 = D.19641 * el_size.73;
      D.19782 = (sizetype) D.19781;
      e_end = e_start + D.19782;
      if (0 != 0) goto <D.19783>; else goto <D.19784>;
      <D.19783>:
      D.19774 = vt->desc;
      D.19779 = vt->klass;
      D.19785 = D.19779->name_space;
      D.19779 = vt->klass;
      D.19786 = D.19779->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19774, D.19785, D.19786);
      <D.19784>:
      goto <D.18414>;
      <D.18413>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.74 = bitmap_data;
          bitmap_data = bitmap_data.74 + 8;
          _bmap = *bitmap_data.74;
          start_run = _objptr;
          goto <D.18408>;
          <D.18407>:
          D.19788 = _bmap & 1;
          if (D.19788 != 0) goto <D.19789>; else goto <D.19790>;
          <D.19789>:
          {
            void * __old;
            void * __copy;

            __old = *_objptr;
            if (__old != 0B) goto <D.19791>; else goto <D.19792>;
            <D.19791>:
            split_nursery_parallel_copy_object (_objptr, queue);
            __copy = *_objptr;
            if (0 != 0) goto <D.19793>; else goto <D.19794>;
            <D.19793>:
            if (__old != __copy) goto <D.19795>; else goto <D.19796>;
            <D.19795>:
            gc_debug_file.59 = gc_debug_file;
            D.19797 = *_objptr;
            fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19797, __old);
            gc_debug_file.59 = gc_debug_file;
            fflush (gc_debug_file.59);
            <D.19796>:
            <D.19794>:
            D.19801 = sgen_ptr_in_nursery (__copy);
            if (D.19801 != 0) goto <D.19802>; else goto <D.19799>;
            <D.19802>:
            D.19803 = sgen_ptr_in_nursery (_objptr);
            if (D.19803 == 0) goto <D.19804>; else goto <D.19799>;
            <D.19804>:
            iftmp.75 = 1;
            goto <D.19800>;
            <D.19799>:
            iftmp.75 = 0;
            <D.19800>:
            D.19805 = iftmp.75 != 0;
            D.19806 = (long int) D.19805;
            D.19807 = __builtin_expect (D.19806, 0);
            if (D.19807 != 0) goto <D.19808>; else goto <D.19809>;
            <D.19808>:
            sgen_add_to_global_remset (_objptr, __copy);
            <D.19809>:
            <D.19792>:
          }
          <D.19790>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18408>:
          if (_bmap != 0) goto <D.18407>; else goto <D.18409>;
          <D.18409>:
          _objptr = start_run + 512;
        }
        <D.18411>:
        bwords.76 = bwords;
        bwords = bwords.76 + 4294967295;
        if (bwords.76 != 0) goto <D.18410>; else goto <D.18412>;
        <D.18412>:
        D.19811 = (sizetype) el_size;
        e_start = e_start + D.19811;
      }
      <D.18414>:
      if (e_start < e_end) goto <D.18413>; else goto <D.18415>;
      <D.18415>:
    }
    goto <D.18322>;
    <D.18416>:
    goto <D.18322>;
    <D.18417>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.18322>:
  }
}


split_nursery_parallel_copy_object (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.77;
  int D.19816;
  long unsigned int D.19819;
  long unsigned int D.19820;
  long unsigned int D.19823;
  int D.19826;
  unsigned int D.19829;
  unsigned int D.19830;
  long unsigned int D.19831;
  void * D.19832;
  long unsigned int D.19833;
  _Bool D.19834;
  long int D.19835;
  long int D.19836;
  long unsigned int destination.78;
  long unsigned int D.19840;
  void * D.19841;
  void * D.19842;
  struct SgenGrayQueue * iftmp.79;
  int D.19850;
  _Bool D.19854;
  long int D.19855;
  long int D.19856;
  char * obj;
  mword vtable_word;
  mword objsize;
  struct MonoVTable * vt;
  void * destination;
  gboolean has_references;

  obj = *obj_slot;
  if (0 != 0) goto <D.19813>; else goto <D.19814>;
  <D.19813>:
  current_collection_generation.77 = current_collection_generation;
  monoeg_g_log (0B, 4, "calling minor-par-copy from a %d generation collection", current_collection_generation.77);
  <D.18304>:
  goto <D.18304>;
  <D.19814>:
  D.19816 = sgen_ptr_in_nursery (obj);
  if (D.19816 == 0) goto <D.19817>; else goto <D.19818>;
  <D.19817>:
  return;
  <D.19818>:
  vtable_word = MEM[(mword *)obj];
  D.19819 = vtable_word & 18446744073709551612;
  vt = (struct MonoVTable *) D.19819;
  D.19820 = vtable_word & 1;
  if (D.19820 != 0) goto <D.19821>; else goto <D.19822>;
  <D.19821>:
  *obj_slot = vt;
  return;
  <D.19822>:
  D.19823 = vtable_word & 2;
  if (D.19823 != 0) goto <D.19824>; else goto <D.19825>;
  <D.19824>:
  return;
  <D.19825>:
  D.19826 = sgen_nursery_is_to_space (obj);
  if (D.19826 != 0) goto <D.19827>; else goto <D.19828>;
  <D.19827>:
  return;
  <D.19828>:
  D.19829 = sgen_par_object_get_size (vt, obj);
  D.19830 = D.19829 + 7;
  D.19831 = (long unsigned int) D.19830;
  objsize = D.19831 & 4294967288;
  D.19832 = vt->gc_descr;
  D.19833 = (long unsigned int) D.19832;
  has_references = sgen_gc_descr_has_references (D.19833);
  destination = par_alloc_for_promotion (vt, obj, objsize, has_references);
  D.19834 = destination == 0B;
  D.19835 = (long int) D.19834;
  D.19836 = __builtin_expect (D.19835, 0);
  if (D.19836 != 0) goto <D.19837>; else goto <D.19838>;
  <D.19837>:
  sgen_parallel_pin_or_update (obj_slot, obj, vt, queue);
  return;
  <D.19838>:
  MEM[(struct MonoVTable * *)destination] = vt;
  destination.78 = (long unsigned int) destination;
  D.19840 = destination.78 | 1;
  D.19841 = (void *) D.19840;
  D.19842 = InterlockedCompareExchangePointer (obj, D.19841, vt);
  if (D.19842 == vt) goto <D.19843>; else goto <D.19844>;
  <D.19843>:
  if (has_references != 0) goto <D.19846>; else goto <D.19847>;
  <D.19846>:
  iftmp.79 = queue;
  goto <D.19848>;
  <D.19847>:
  iftmp.79 = 0B;
  <D.19848>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.79);
  obj = destination;
  *obj_slot = obj;
  goto <D.19849>;
  <D.19844>:
  D.19850 = sgen_ptr_in_nursery (destination);
  if (D.19850 == 0) goto <D.19851>; else goto <D.19852>;
  <D.19851>:
  MEM[(void * *)destination] = 0B;
  goto <D.19853>;
  <D.19852>:
  memset (destination, 0, objsize);
  <D.19853>:
  vtable_word = MEM[(mword *)obj];
  D.19820 = vtable_word & 1;
  D.19854 = D.19820 == 0;
  D.19855 = (long int) D.19854;
  D.19856 = __builtin_expect (D.19855, 0);
  if (D.19856 != 0) goto <D.19857>; else goto <D.19858>;
  <D.19857>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-minor-copy-object.h", 291, "vtable_word & SGEN_FORWARDED_BIT");
  <D.19858>:
  D.19819 = vtable_word & 18446744073709551612;
  obj = (char *) D.19819;
  *obj_slot = obj;
  <D.19849>:
}


par_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int promote_age.80;
  char * D.19863;
  void * (*<T2fcb>) (struct MonoVTable *, int, gboolean) D.19864;
  int D.19865;
  char * D.19866;
  char * D.19867;
  _Bool D.19868;
  long int D.19869;
  long int D.19870;
  char * * D.19873;
  void * D.19874;
  char * p;
  int age;
  void restart = <<< error >>>;

  age = get_object_age (obj);
  promote_age.80 = promote_age;
  if (age >= promote_age.80) goto <D.19861>; else goto <D.19862>;
  <D.19861>:
  D.19864 = major_collector.par_alloc_object;
  D.19865 = (int) objsize;
  D.19863 = D.19864 (vtable, D.19865, has_references);
  return D.19863;
  <D.19862>:
  restart:
  p = age_alloc_buffers[age].next;
  D.19866 = p + objsize;
  D.19867 = age_alloc_buffers[age].end;
  D.19868 = D.19866 <= D.19867;
  D.19869 = (long int) D.19868;
  D.19870 = __builtin_expect (D.19869, 1);
  if (D.19870 != 0) goto <D.19871>; else goto <D.19872>;
  <D.19871>:
  D.19873 = &age_alloc_buffers[age].next;
  D.19866 = p + objsize;
  D.19874 = InterlockedCompareExchangePointer (D.19873, D.19866, p);
  if (D.19874 != p) goto restart; else goto <D.19875>;
  <D.19875>:
  goto <D.19876>;
  <D.19872>:
  p = par_alloc_for_promotion_slow_path (age, objsize);
  if (p == 0B) goto <D.19877>; else goto <D.19878>;
  <D.19877>:
  D.19864 = major_collector.par_alloc_object;
  D.19865 = (int) objsize;
  D.19863 = D.19864 (vtable, D.19865, has_references);
  return D.19863;
  <D.19878>:
  <D.19876>:
  MEM[(struct MonoVTable * *)p] = vtable;
  D.19863 = p;
  return D.19863;
}


par_alloc_for_promotion_slow_path (int age, size_t objsize)
{
  long unsigned int D.19880;
  char * D.19881;
  char * D.19882;
  _Bool D.19883;
  long int D.19884;
  long int D.19885;
  char * * D.19888;
  void * D.19889;
  void * D.19894;
  long unsigned int D.19895;
  long unsigned int D.19896;
  long unsigned int allocated_size.81;
  char * D.19900;
  char * D.19901;
  char * p;
  size_t allocated_size;
  size_t aligned_objsize;
  void restart = <<< error >>>;

  try
    {
      D.19880 = objsize + 511;
      aligned_objsize = D.19880 & 18446744073709551104;
      pthread_mutex_lock (&par_alloc_buffer_refill_mutex);
      restart:
      p = age_alloc_buffers[age].next;
      D.19881 = p + objsize;
      D.19882 = age_alloc_buffers[age].end;
      D.19883 = D.19881 <= D.19882;
      D.19884 = (long int) D.19883;
      D.19885 = __builtin_expect (D.19884, 1);
      if (D.19885 != 0) goto <D.19886>; else goto <D.19887>;
      <D.19886>:
      D.19888 = &age_alloc_buffers[age].next;
      D.19881 = p + objsize;
      D.19889 = InterlockedCompareExchangePointer (D.19888, D.19881, p);
      if (D.19889 != p) goto restart; else goto <D.19890>;
      <D.19890>:
      goto <D.19891>;
      <D.19887>:
      {
        char * end;

        end = age_alloc_buffers[age].end;
        if (end != 0B) goto <D.19892>; else goto <D.19893>;
        <D.19892>:
        <D.18171>:
        p = age_alloc_buffers[age].next;
        D.19888 = &age_alloc_buffers[age].next;
        D.19894 = InterlockedCompareExchangePointer (D.19888, end, p);
        if (D.19894 != p) goto <D.18171>; else goto <D.18172>;
        <D.18172>:
        sgen_clear_range (p, end);
        <D.19893>:
        age_alloc_buffers[age].end = 0B;
        D.19895 = MAX_EXPR <aligned_objsize, 4096>;
        D.19896 = MAX_EXPR <aligned_objsize, 512>;
        p = sgen_fragment_allocator_par_range_alloc (&collector_allocator, D.19895, D.19896, &allocated_size);
        if (p != 0B) goto <D.19897>; else goto <D.19898>;
        <D.19897>:
        allocated_size.81 = allocated_size;
        D.19900 = p + allocated_size.81;
        set_age_in_range (p, D.19900, age);
        D.19881 = p + objsize;
        age_alloc_buffers[age].next = D.19881;
        allocated_size.81 = allocated_size;
        D.19900 = p + allocated_size.81;
        age_alloc_buffers[age].end = D.19900;
        <D.19898>:
      }
      <D.19891>:
      pthread_mutex_unlock (&par_alloc_buffer_refill_mutex);
      D.19901 = p;
      return D.19901;
    }
  finally
    {
      allocated_size = {CLOBBER};
    }
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.19904;
  long unsigned int comp.82;
  long unsigned int exch.83;
  long unsigned int D.19907;

  comp.82 = (long unsigned int) comp;
  exch.83 = (long unsigned int) exch;
  D.19907 = __sync_val_compare_and_swap_8 (dest, comp.82, exch.83);
  D.19904 = (void *) D.19907;
  return D.19904;
}


__attribute__((always_inline))
split_nursery_serial_copy_object (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.84;
  int D.19912;
  struct FILE * gc_debug_file.85;
  char * iftmp.86;
  long unsigned int D.19919;
  long unsigned int D.19920;
  long unsigned int D.19923;
  long unsigned int D.19931;
  _Bool D.19932;
  long int D.19933;
  long int D.19934;
  int D.19941;
  void * D.19948;
  char * forwarded;
  char * obj;

  obj = *obj_slot;
  if (0 != 0) goto <D.19909>; else goto <D.19910>;
  <D.19909>:
  current_collection_generation.84 = current_collection_generation;
  monoeg_g_log (0B, 4, "calling minor-serial-copy from a %d generation collection", current_collection_generation.84);
  <D.18279>:
  goto <D.18279>;
  <D.19910>:
  D.19912 = sgen_ptr_in_nursery (obj);
  if (D.19912 == 0) goto <D.19913>; else goto <D.19914>;
  <D.19913>:
  return;
  <D.19914>:
  if (0 != 0) goto <D.19915>; else goto <D.19916>;
  <D.19915>:
  gc_debug_file.85 = gc_debug_file;
  fprintf (gc_debug_file.85, "Precise copy of %p from %p\n", obj, obj_slot);
  gc_debug_file.85 = gc_debug_file;
  fflush (gc_debug_file.85);
  <D.19916>:
  D.19919 = MEM[(mword *)obj];
  D.19920 = D.19919 & 1;
  if (D.19920 != 0) goto <D.19921>; else goto <D.19922>;
  <D.19921>:
  D.19919 = MEM[(mword *)obj];
  D.19923 = D.19919 & 18446744073709551612;
  iftmp.86 = (char *) D.19923;
  goto <D.19924>;
  <D.19922>:
  iftmp.86 = 0B;
  <D.19924>:
  forwarded = iftmp.86;
  if (forwarded != 0B) goto <D.19925>; else goto <D.19926>;
  <D.19925>:
  if (0 != 0) goto <D.19927>; else goto <D.19928>;
  <D.19927>:
  monoeg_g_log (0B, 4, "forwarded object %p has no gc descriptor", forwarded);
  <D.18280>:
  goto <D.18280>;
  <D.19928>:
  if (0 != 0) goto <D.19929>; else goto <D.19930>;
  <D.19929>:
  gc_debug_file.85 = gc_debug_file;
  fprintf (gc_debug_file.85, " (already forwarded to %p)\n", forwarded);
  gc_debug_file.85 = gc_debug_file;
  fflush (gc_debug_file.85);
  <D.19930>:
  *obj_slot = forwarded;
  return;
  <D.19926>:
  D.19919 = MEM[(mword *)obj];
  D.19931 = D.19919 & 2;
  D.19932 = D.19931 != 0;
  D.19933 = (long int) D.19932;
  D.19934 = __builtin_expect (D.19933, 0);
  if (D.19934 != 0) goto <D.19935>; else goto <D.19936>;
  <D.19935>:
  if (0 != 0) goto <D.19937>; else goto <D.19938>;
  <D.19937>:
  monoeg_g_log (0B, 4, "pinned object %p has no gc descriptor", obj);
  <D.18281>:
  goto <D.18281>;
  <D.19938>:
  if (0 != 0) goto <D.19939>; else goto <D.19940>;
  <D.19939>:
  gc_debug_file.85 = gc_debug_file;
  fprintf (gc_debug_file.85, " (pinned, no change)\n");
  gc_debug_file.85 = gc_debug_file;
  fflush (gc_debug_file.85);
  <D.19940>:
  return;
  <D.19936>:
  D.19941 = sgen_nursery_is_to_space (obj);
  if (D.19941 != 0) goto <D.19942>; else goto <D.19943>;
  <D.19942>:
  if (0 != 0) goto <D.19944>; else goto <D.19945>;
  <D.19944>:
  monoeg_g_log (0B, 4, "to space object %p has no gc descriptor", obj);
  <D.18282>:
  goto <D.18282>;
  <D.19945>:
  if (0 != 0) goto <D.19946>; else goto <D.19947>;
  <D.19946>:
  gc_debug_file.85 = gc_debug_file;
  fprintf (gc_debug_file.85, " (tospace, no change)\n");
  gc_debug_file.85 = gc_debug_file;
  fflush (gc_debug_file.85);
  <D.19947>:
  return;
  <D.19943>:
  D.19948 = copy_object_no_checks (obj, queue);
  *obj_slot = D.19948;
}


print_gc_param_usage ()
{
  struct _IO_FILE * stderr.87;

  stderr.87 = stderr;
  fprintf (stderr.87, "  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);
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.19951;

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


handle_gc_param (const char * opt)
{
  int D.19953;
  char * D.19956;
  unsigned int percentage.88;
  unsigned int D.19958;
  struct _IO_FILE * stderr.89;
  float D.19962;
  float D.19963;
  gboolean D.19964;
  int D.19965;
  char * D.19968;
  int D.19969;
  int promote_age.90;
  unsigned int promote_age.91;
  unsigned int D.19972;

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

    D.19956 = __builtin_strchr (opt, 61);
    arg = D.19956 + 1;
    percentage = atoi (arg);
    percentage.88 = (unsigned int) percentage;
    D.19958 = percentage.88 + 4294967295;
    if (D.19958 > 99) goto <D.19959>; else goto <D.19960>;
    <D.19959>:
    stderr.89 = stderr;
    fprintf (stderr.89, "alloc-ratio must be an integer in the range 1-100.\n");
    exit (1);
    <D.19960>:
    D.19962 = (float) percentage;
    D.19963 = D.19962 / 1.0e+2;
    alloc_ratio = D.19963;
    D.19964 = 1;
    return D.19964;
  }
  <D.19955>:
  D.19965 = monoeg_g_str_has_prefix (opt, "promotion-age=");
  if (D.19965 != 0) goto <D.19966>; else goto <D.19967>;
  <D.19966>:
  {
    const char * arg;

    D.19968 = __builtin_strchr (opt, 61);
    arg = D.19968 + 1;
    D.19969 = atoi (arg);
    promote_age = D.19969;
    promote_age.90 = promote_age;
    promote_age.91 = (unsigned int) promote_age.90;
    D.19972 = promote_age.91 + 4294967295;
    if (D.19972 > 13) goto <D.19973>; else goto <D.19974>;
    <D.19973>:
    stderr.89 = stderr;
    fprintf (stderr.89, "promotion-age must be an integer in the range 1-%d.\n", 14);
    exit (1);
    <D.19974>:
    D.19964 = 1;
    return D.19964;
  }
  <D.19967>:
  D.19964 = 0;
  return D.19964;
}


__attribute__((__gnu_inline__, __pure__, __leaf__, __nothrow__))
atoi (const char * __nptr)
{
  int D.19976;
  long int D.19977;

  D.19977 = strtol (__nptr, 0B, 10);
  D.19976 = (int) D.19977;
  return D.19976;
}


init_nursery (struct SgenFragmentAllocator * allocator, char * start, char * end)
{
  long int end.92;
  long int start.93;
  long int D.19981;
  float D.19982;
  float alloc_ratio.94;
  float D.19984;
  long unsigned int D.19985;
  long unsigned int start.95;
  long unsigned int D.19987;
  long unsigned int D.19988;
  char * D.19989;
  char * promotion_barrier.96;
  long int D.19991;
  int D.19992;
  int region_age_size.97;
  long unsigned int D.19994;
  void * D.19995;
  int alloc_quote;

  end.92 = (long int) end;
  start.93 = (long int) start;
  D.19981 = end.92 - start.93;
  D.19982 = (float) D.19981;
  alloc_ratio.94 = alloc_ratio;
  D.19984 = D.19982 * alloc_ratio.94;
  alloc_quote = (int) D.19984;
  D.19985 = (long unsigned int) alloc_quote;
  start.95 = (long unsigned int) start;
  D.19987 = D.19985 + start.95;
  D.19988 = D.19987 & 18446744073709551608;
  D.19989 = (char *) D.19988;
  promotion_barrier = D.19989;
  promotion_barrier.96 = promotion_barrier;
  sgen_fragment_allocator_add (allocator, start, promotion_barrier.96);
  promotion_barrier.96 = promotion_barrier;
  sgen_fragment_allocator_add (&collector_allocator, promotion_barrier.96, end);
  end.92 = (long int) end;
  start.93 = (long int) start;
  D.19981 = end.92 - start.93;
  D.19991 = D.19981 >> 9;
  D.19992 = (int) D.19991;
  region_age_size = D.19992;
  region_age_size.97 = region_age_size;
  D.19994 = (long unsigned int) region_age_size.97;
  D.19995 = monoeg_malloc0 (D.19994);
  region_age = D.19995;
}


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


fragment_list_split (struct SgenFragmentAllocator * allocator)
{
  char * D.19996;
  char * promotion_barrier.98;
  char * D.20000;
  struct SgenFragment * D.20003;
  struct SgenFragment * D.20004;
  char * D.20005;
  char * D.20006;
  _Bool D.20007;
  long int D.20008;
  long int D.20009;
  struct SgenFragment * D.20012;
  struct SgenFragment * D.20015;
  struct SgenFragment * prev;
  struct SgenFragment * list;

  prev = 0B;
  list = allocator->region_head;
  goto <D.18145>;
  <D.18144>:
  D.19996 = list->fragment_end;
  promotion_barrier.98 = promotion_barrier;
  if (D.19996 > promotion_barrier.98) goto <D.19998>; else goto <D.19999>;
  <D.19998>:
  D.20000 = list->fragment_start;
  promotion_barrier.98 = promotion_barrier;
  if (D.20000 < promotion_barrier.98) goto <D.20001>; else goto <D.20002>;
  <D.20001>:
  {
    struct SgenFragment * res;

    res = sgen_fragment_allocator_alloc ();
    promotion_barrier.98 = promotion_barrier;
    res->fragment_start = promotion_barrier.98;
    promotion_barrier.98 = promotion_barrier;
    res->fragment_next = promotion_barrier.98;
    D.19996 = list->fragment_end;
    res->fragment_end = D.19996;
    D.20003 = list->next;
    res->next = D.20003;
    D.20004 = list->next_in_order;
    res->next_in_order = D.20004;
    D.20005 = res->fragment_end;
    D.20006 = res->fragment_start;
    D.20007 = D.20005 <= D.20006;
    D.20008 = (long int) D.20007;
    D.20009 = __builtin_expect (D.20008, 0);
    if (D.20009 != 0) goto <D.20010>; else goto <D.20011>;
    <D.20010>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-split-nursery.c", 220, "res->fragment_end > res->fragment_start");
    <D.20011>:
    promotion_barrier.98 = promotion_barrier;
    list->fragment_end = promotion_barrier.98;
    list->next_in_order = 0B;
    D.20004 = list->next_in_order;
    list->next = D.20004;
    D.20000 = list->fragment_start;
    D.19996 = list->fragment_end;
    set_age_in_range (D.20000, D.19996, 0);
    allocator->alloc_head = res;
    D.20012 = allocator->alloc_head;
    allocator->region_head = D.20012;
    return;
  }
  <D.20002>:
  if (prev != 0B) goto <D.20013>; else goto <D.20014>;
  <D.20013>:
  prev->next_in_order = 0B;
  D.20015 = prev->next_in_order;
  prev->next = D.20015;
  <D.20014>:
  allocator->alloc_head = list;
  D.20012 = allocator->alloc_head;
  allocator->region_head = D.20012;
  return;
  <D.19999>:
  D.20000 = list->fragment_start;
  D.19996 = list->fragment_end;
  set_age_in_range (D.20000, D.19996, 0);
  prev = list;
  list = list->next;
  <D.18145>:
  if (list != 0B) goto <D.18144>; else goto <D.18146>;
  <D.18146>:
  allocator->alloc_head = 0B;
  D.20012 = allocator->alloc_head;
  allocator->region_head = D.20012;
}


build_fragments_release_exclude_head ()
{
  sgen_fragment_allocator_release (&collector_allocator);
}


build_fragments_get_exclude_head ()
{
  char * D.20017;
  char * D.20020;
  struct SgenFragment * D.20021;
  int i;

  i = 0;
  goto <D.18199>;
  <D.18198>:
  D.20017 = age_alloc_buffers[i].end;
  if (D.20017 != 0B) goto <D.20018>; else goto <D.20019>;
  <D.20018>:
  D.20020 = age_alloc_buffers[i].next;
  D.20017 = age_alloc_buffers[i].end;
  sgen_clear_range (D.20020, D.20017);
  <D.20019>:
  i = i + 1;
  <D.18199>:
  if (i <= 14) goto <D.18198>; else goto <D.18200>;
  <D.18200>:
  D.20021 = collector_allocator.region_head;
  return D.20021;
}


clear_fragments ()
{
  sgen_clear_allocator_fragments (&collector_allocator);
}


prepare_to_space (char * to_space_bitmap, int space_bitmap_size)
{
  long unsigned int D.20023;
  char * D.20024;
  long unsigned int D.20025;
  long unsigned int D.20026;
  long unsigned int D.20027;
  char * D.20028;
  long unsigned int D.20029;
  long unsigned int D.20030;
  long int end.99;
  long int start.100;
  long int D.20033;
  char * D.20036;
  struct SgenFragment * D.20037;
  struct SgenFragment * * previous;
  struct SgenFragment * frag;

  D.20023 = (long unsigned int) space_bitmap_size;
  memset (to_space_bitmap, 0, D.20023);
  memset (&age_alloc_buffers, 0, 240);
  previous = &collector_allocator.alloc_head;
  frag = *previous;
  goto <D.18217>;
  <D.18216>:
  {
    char * start;
    char * end;

    D.20024 = frag->fragment_next;
    D.20025 = (long unsigned int) D.20024;
    D.20026 = D.20025 + 511;
    D.20027 = D.20026 & 18446744073709551104;
    start = (char *) D.20027;
    D.20028 = frag->fragment_end;
    D.20029 = (long unsigned int) D.20028;
    D.20030 = D.20029 & 18446744073709551104;
    end = (char *) D.20030;
    end.99 = (long int) end;
    start.100 = (long int) start;
    D.20033 = end.99 - start.100;
    if (D.20033 <= 511) goto <D.20034>; else goto <D.20035>;
    <D.20034>:
    D.20024 = frag->fragment_next;
    D.20028 = frag->fragment_end;
    sgen_clear_range (D.20024, D.20028);
    D.20036 = frag->fragment_start;
    frag->fragment_end = D.20036;
    D.20028 = frag->fragment_end;
    frag->fragment_next = D.20028;
    D.20037 = frag->next;
    *previous = D.20037;
    // predicted unlikely by continue predictor.
    goto <D.18215>;
    <D.20035>:
    sgen_clear_range (start, end);
    D.20024 = frag->fragment_next;
    if (D.20024 != start) goto <D.20038>; else goto <D.20039>;
    <D.20038>:
    D.20024 = frag->fragment_next;
    sgen_clear_range (D.20024, start);
    <D.20039>:
    D.20028 = frag->fragment_end;
    if (D.20028 != end) goto <D.20040>; else goto <D.20041>;
    <D.20040>:
    D.20028 = frag->fragment_end;
    sgen_clear_range (end, D.20028);
    <D.20041>:
    frag->fragment_next = start;
    D.20024 = frag->fragment_next;
    frag->fragment_start = D.20024;
    frag->fragment_end = end;
    mark_bits_in_range (to_space_bitmap, start, end);
    previous = &frag->next;
  }
  <D.18215>:
  frag = *previous;
  <D.18217>:
  if (frag != 0B) goto <D.18216>; else goto <D.18218>;
  <D.18218>:
}


mark_bits_in_range (char * space_bitmap, char * start, char * end)
{
  long unsigned int start.101;
  long unsigned int D.20043;
  long unsigned int end.102;
  long unsigned int D.20045;
  long unsigned int D.20046;

  start.101 = (long unsigned int) start;
  D.20043 = start.101 & 18446744073709551104;
  start = (char *) D.20043;
  end.102 = (long unsigned int) end;
  D.20045 = end.102 + 511;
  D.20046 = D.20045 & 18446744073709551104;
  end = (char *) D.20046;
  goto <D.18136>;
  <D.18135>:
  mark_bit (space_bitmap, start);
  start = start + 512;
  <D.18136>:
  if (start < end) goto <D.18135>; else goto <D.18137>;
  <D.18137>:
}


mark_bit (char * space_bitmap, char * pos)
{
  long int pos.103;
  char * sgen_nursery_start.104;
  long int sgen_nursery_start.105;
  long int D.20050;
  long int D.20051;
  int sgen_space_bitmap_size.106;
  _Bool D.20053;
  long int D.20054;
  long int D.20055;
  sizetype D.20058;
  char * D.20059;
  char D.20060;
  signed char D.20061;
  int D.20062;
  signed char D.20063;
  signed char D.20064;
  char D.20065;
  int idx;
  int byte;
  int bit;

  pos.103 = (long int) pos;
  sgen_nursery_start.104 = sgen_nursery_start;
  sgen_nursery_start.105 = (long int) sgen_nursery_start.104;
  D.20050 = pos.103 - sgen_nursery_start.105;
  D.20051 = D.20050 >> 9;
  idx = (int) D.20051;
  byte = idx / 8;
  bit = idx & 7;
  sgen_space_bitmap_size.106 = sgen_space_bitmap_size;
  D.20053 = byte >= sgen_space_bitmap_size.106;
  D.20054 = (long int) D.20053;
  D.20055 = __builtin_expect (D.20054, 0);
  if (D.20055 != 0) goto <D.20056>; else goto <D.20057>;
  <D.20056>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-split-nursery.c", 182, "byte < sgen_space_bitmap_size");
  <D.20057>:
  D.20058 = (sizetype) byte;
  D.20059 = space_bitmap + D.20058;
  D.20058 = (sizetype) byte;
  D.20059 = space_bitmap + D.20058;
  D.20060 = *D.20059;
  D.20061 = (signed char) D.20060;
  D.20062 = 1 << bit;
  D.20063 = (signed char) D.20062;
  D.20064 = D.20061 | D.20063;
  D.20065 = (char) D.20064;
  *D.20059 = D.20065;
}


minor_par_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int D.20066;
  char * D.20069;
  void * (*<T2fcb>) (struct MonoVTable *, int, gboolean) D.20070;
  int D.20071;

  D.20066 = sgen_ptr_in_nursery (obj);
  if (D.20066 == 0) goto <D.20067>; else goto <D.20068>;
  <D.20067>:
  D.20070 = major_collector.par_alloc_object;
  D.20071 = (int) objsize;
  D.20069 = D.20070 (vtable, D.20071, has_references);
  return D.20069;
  <D.20068>:
  D.20069 = par_alloc_for_promotion (vtable, obj, objsize, has_references);
  return D.20069;
}


minor_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int D.20073;
  char * D.20076;
  void * (*<T2fcb>) (struct MonoVTable *, int, gboolean) D.20077;
  int D.20078;

  D.20073 = sgen_ptr_in_nursery (obj);
  if (D.20073 == 0) goto <D.20074>; else goto <D.20075>;
  <D.20074>:
  D.20077 = major_collector.alloc_object;
  D.20078 = (int) objsize;
  D.20076 = D.20077 (vtable, D.20078, has_references);
  return D.20076;
  <D.20075>:
  D.20076 = alloc_for_promotion (vtable, obj, objsize, has_references);
  return D.20076;
}