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.19079;
  long unsigned int D.19080;
  long unsigned int D.19083;
  long unsigned int D.19084;
  long unsigned int D.19085;
  long unsigned int D.19086;
  long unsigned int D.19087;
  long unsigned int D.19088;
  void * D.19093;
  struct FILE * gc_debug_file.0;
  long unsigned int D.19103;
  long unsigned int D.19104;
  int D.19105;
  void * D.19110;
  long unsigned int D.19113;
  long unsigned int D.19114;
  int D.19115;
  long unsigned int D.19122;
  long unsigned int D.19125;
  int D.19126;
  int D.19127;
  unsigned int D.19130;
  unsigned int el_size.1;
  unsigned int D.19132;
  sizetype D.19133;
  void * D.19138;
  int D.19144;
  int D.19145;
  long unsigned int D.19146;
  long unsigned int D.19147;
  long unsigned int D.19148;
  long unsigned int D.19149;
  void * * D.19150;
  void * D.19155;
  sizetype D.19158;
  long unsigned int D.19162;
  void * D.19169;
  long unsigned int D.19172;
  void * D.19179;
  long unsigned int D.19182;
  unsigned int D.19183;
  unsigned int D.19184;
  struct MonoVTable * D.19187;
  struct MonoClass * D.19188;
  const char * D.19189;
  const char * D.19190;
  gsize * bitmap_data.2;
  long unsigned int D.19192;
  void * D.19199;
  int bwords.3;

  start = start + 18446744073709551600;
  D.19079 = desc & 7;
  switch (D.19079) <default: <D.19074>, case 1: <D.19000>, case 2: <D.19009>, case 3: <D.19059>, case 4: <D.19019>, case 5: <D.19052>, case 7: <D.19073>>
  <D.19000>:
  D.19080 = desc & 4294901760;
  if (D.19080 != 0) goto <D.19081>; else goto <D.19082>;
  <D.19081>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.19083 = desc >> 16;
    D.19084 = D.19083 & 255;
    D.19085 = D.19084 * 8;
    _objptr = _objptr + D.19085;
    D.19086 = desc >> 24;
    D.19087 = D.19086 & 255;
    D.19088 = D.19087 * 8;
    _objptr_end = _objptr + D.19088;
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.19089>; else goto <D.19090>;
      <D.19089>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.19091>; else goto <D.19092>;
      <D.19091>:
      D.19093 = *_objptr;
      if (D.19093 != __old) goto <D.19094>; else goto <D.19095>;
      <D.19094>:
      gc_debug_file.0 = gc_debug_file;
      D.19093 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19093, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.19095>:
      <D.19092>:
      <D.19090>:
    }
    _objptr = _objptr + 8;
    goto <D.19006>;
    <D.19005>:
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.19097>; else goto <D.19098>;
      <D.19097>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.19099>; else goto <D.19100>;
      <D.19099>:
      D.19093 = *_objptr;
      if (D.19093 != __old) goto <D.19101>; else goto <D.19102>;
      <D.19101>:
      gc_debug_file.0 = gc_debug_file;
      D.19093 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19093, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.19102>:
      <D.19100>:
      <D.19098>:
    }
    _objptr = _objptr + 8;
    <D.19006>:
    if (_objptr < _objptr_end) goto <D.19005>; else goto <D.19007>;
    <D.19007>:
  }
  <D.19082>:
  goto <D.19008>;
  <D.19009>:
  {
    void * * _objptr;
    gsize _bmap;

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

      _index = __builtin_ctzl (_bmap);
      D.19103 = (long unsigned int) _index;
      D.19104 = D.19103 * 8;
      _objptr = _objptr + D.19104;
      D.19105 = _index + 1;
      _bmap = _bmap >> D.19105;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19106>; else goto <D.19107>;
        <D.19106>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19108>; else goto <D.19109>;
        <D.19108>:
        D.19110 = *_objptr;
        if (D.19110 != __old) goto <D.19111>; else goto <D.19112>;
        <D.19111>:
        gc_debug_file.0 = gc_debug_file;
        D.19110 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19110, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.19112>:
        <D.19109>:
        <D.19107>:
      }
      _objptr = _objptr + 8;
    }
    goto <D.19017>;
    <D.19016>:
    {
      int _index;

      _index = __builtin_ctzl (_bmap);
      D.19113 = (long unsigned int) _index;
      D.19114 = D.19113 * 8;
      _objptr = _objptr + D.19114;
      D.19115 = _index + 1;
      _bmap = _bmap >> D.19115;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19116>; else goto <D.19117>;
        <D.19116>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19118>; else goto <D.19119>;
        <D.19118>:
        D.19110 = *_objptr;
        if (D.19110 != __old) goto <D.19120>; else goto <D.19121>;
        <D.19120>:
        gc_debug_file.0 = gc_debug_file;
        D.19110 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19110, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.19121>:
        <D.19119>:
        <D.19117>:
      }
      _objptr = _objptr + 8;
    }
    <D.19017>:
    if (_bmap != 0) goto <D.19016>; else goto <D.19018>;
    <D.19018>:
  }
  goto <D.19008>;
  <D.19019>:
  D.19122 = desc & 4294950912;
  if (D.19122 != 0) goto <D.19123>; else goto <D.19124>;
  <D.19123>:
  {
    int el_size;
    int etype;

    D.19125 = desc >> 3;
    D.19126 = (int) D.19125;
    el_size = D.19126 & 1023;
    D.19127 = (int) desc;
    etype = D.19127 & 49152;
    if (etype == 16384) goto <D.19128>; else goto <D.19129>;
    <D.19128>:
    {
      void * * p;
      void * * end_refs;

      p = start + 32;
      D.19130 = MEM[(struct MonoArray *)start].max_length;
      el_size.1 = (unsigned int) el_size;
      D.19132 = D.19130 * el_size.1;
      D.19133 = (sizetype) D.19132;
      end_refs = p + D.19133;
      goto <D.19026>;
      <D.19025>:
      {
        void * __old;

        __old = *p;
        if (__old != 0B) goto <D.19134>; else goto <D.19135>;
        <D.19134>:
        split_nursery_serial_copy_object_from_obj (p, queue);
        if (0 != 0) goto <D.19136>; else goto <D.19137>;
        <D.19136>:
        D.19138 = *p;
        if (D.19138 != __old) goto <D.19139>; else goto <D.19140>;
        <D.19139>:
        gc_debug_file.0 = gc_debug_file;
        D.19138 = *p;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", p, D.19138, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.19140>:
        <D.19137>:
        <D.19135>:
      }
      p = p + 8;
      <D.19026>:
      if (p < end_refs) goto <D.19025>; else goto <D.19027>;
      <D.19027>:
    }
    goto <D.19141>;
    <D.19129>:
    if (etype == 32768) goto <D.19142>; else goto <D.19143>;
    <D.19142>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.19083 = desc >> 16;
      D.19144 = (int) D.19083;
      offset = D.19144 & 255;
      D.19086 = desc >> 24;
      D.19145 = (int) D.19086;
      num_refs = D.19145 & 255;
      e_start = start + 32;
      D.19130 = MEM[(struct MonoArray *)start].max_length;
      el_size.1 = (unsigned int) el_size;
      D.19132 = D.19130 * el_size.1;
      D.19133 = (sizetype) D.19132;
      e_end = e_start + D.19133;
      goto <D.19039>;
      <D.19038>:
      {
        void * * p;
        int i;

        p = e_start;
        D.19146 = (long unsigned int) offset;
        D.19147 = D.19146 * 8;
        p = p + D.19147;
        i = 0;
        goto <D.19036>;
        <D.19035>:
        {
          void * __old;

          D.19148 = (long unsigned int) i;
          D.19149 = D.19148 * 8;
          D.19150 = p + D.19149;
          __old = *D.19150;
          if (__old != 0B) goto <D.19151>; else goto <D.19152>;
          <D.19151>:
          D.19148 = (long unsigned int) i;
          D.19149 = D.19148 * 8;
          D.19150 = p + D.19149;
          split_nursery_serial_copy_object_from_obj (D.19150, queue);
          if (0 != 0) goto <D.19153>; else goto <D.19154>;
          <D.19153>:
          D.19148 = (long unsigned int) i;
          D.19149 = D.19148 * 8;
          D.19150 = p + D.19149;
          D.19155 = *D.19150;
          if (D.19155 != __old) goto <D.19156>; else goto <D.19157>;
          <D.19156>:
          gc_debug_file.0 = gc_debug_file;
          D.19148 = (long unsigned int) i;
          D.19149 = D.19148 * 8;
          D.19150 = p + D.19149;
          D.19148 = (long unsigned int) i;
          D.19149 = D.19148 * 8;
          D.19150 = p + D.19149;
          D.19155 = *D.19150;
          fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", D.19150, D.19155, __old);
          gc_debug_file.0 = gc_debug_file;
          fflush (gc_debug_file.0);
          <D.19157>:
          <D.19154>:
          <D.19152>:
        }
        i = i + 1;
        <D.19036>:
        if (i < num_refs) goto <D.19035>; else goto <D.19037>;
        <D.19037>:
        D.19158 = (sizetype) el_size;
        e_start = e_start + D.19158;
      }
      <D.19039>:
      if (e_start < e_end) goto <D.19038>; else goto <D.19040>;
      <D.19040>:
    }
    goto <D.19159>;
    <D.19143>:
    if (etype == 49152) goto <D.19160>; else goto <D.19161>;
    <D.19160>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 32;
      D.19130 = MEM[(struct MonoArray *)start].max_length;
      el_size.1 = (unsigned int) el_size;
      D.19132 = D.19130 * el_size.1;
      D.19133 = (sizetype) D.19132;
      e_end = e_start + D.19133;
      goto <D.19050>;
      <D.19049>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.19047>;
        <D.19046>:
        D.19162 = _bmap & 1;
        if (D.19162 != 0) goto <D.19163>; else goto <D.19164>;
        <D.19163>:
        {
          void * __old;

          __old = *p;
          if (__old != 0B) goto <D.19165>; else goto <D.19166>;
          <D.19165>:
          split_nursery_serial_copy_object_from_obj (p, queue);
          if (0 != 0) goto <D.19167>; else goto <D.19168>;
          <D.19167>:
          D.19169 = *p;
          if (D.19169 != __old) goto <D.19170>; else goto <D.19171>;
          <D.19170>:
          gc_debug_file.0 = gc_debug_file;
          D.19169 = *p;
          fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", p, D.19169, __old);
          gc_debug_file.0 = gc_debug_file;
          fflush (gc_debug_file.0);
          <D.19171>:
          <D.19168>:
          <D.19166>:
        }
        <D.19164>:
        _bmap = _bmap >> 1;
        p = p + 8;
        <D.19047>:
        if (_bmap != 0) goto <D.19046>; else goto <D.19048>;
        <D.19048>:
        D.19158 = (sizetype) el_size;
        e_start = e_start + D.19158;
      }
      <D.19050>:
      if (e_start < e_end) goto <D.19049>; else goto <D.19051>;
      <D.19051>:
    }
    <D.19161>:
    <D.19159>:
    <D.19141>:
  }
  <D.19124>:
  goto <D.19008>;
  <D.19052>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 3;
    _objptr = _objptr + 16;
    goto <D.19057>;
    <D.19056>:
    D.19172 = _bmap & 1;
    if (D.19172 != 0) goto <D.19173>; else goto <D.19174>;
    <D.19173>:
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.19175>; else goto <D.19176>;
      <D.19175>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.19177>; else goto <D.19178>;
      <D.19177>:
      D.19179 = *_objptr;
      if (D.19179 != __old) goto <D.19180>; else goto <D.19181>;
      <D.19180>:
      gc_debug_file.0 = gc_debug_file;
      D.19179 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19179, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.19181>:
      <D.19178>:
      <D.19176>:
    }
    <D.19174>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 8;
    <D.19057>:
    if (_bmap != 0) goto <D.19056>; else goto <D.19058>;
    <D.19058>:
  }
  goto <D.19008>;
  <D.19059>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.19182 = *bitmap_data;
    D.19183 = (unsigned int) D.19182;
    D.19184 = D.19183 + 4294967295;
    bwords = (int) D.19184;
    start_run = _objptr;
    bitmap_data = bitmap_data + 8;
    if (0 != 0) goto <D.19185>; else goto <D.19186>;
    <D.19185>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.19187 = myobj->vtable;
      D.19188 = D.19187->klass;
      D.19189 = D.19188->name_space;
      D.19187 = myobj->vtable;
      D.19188 = D.19187->klass;
      D.19190 = D.19188->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19189, D.19190);
    }
    <D.19186>:
    goto <D.19071>;
    <D.19070>:
    {
      gsize _bmap;

      bitmap_data.2 = bitmap_data;
      bitmap_data = bitmap_data.2 + 8;
      _bmap = *bitmap_data.2;
      _objptr = start_run;
      goto <D.19068>;
      <D.19067>:
      D.19192 = _bmap & 1;
      if (D.19192 != 0) goto <D.19193>; else goto <D.19194>;
      <D.19193>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19195>; else goto <D.19196>;
        <D.19195>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19197>; else goto <D.19198>;
        <D.19197>:
        D.19199 = *_objptr;
        if (D.19199 != __old) goto <D.19200>; else goto <D.19201>;
        <D.19200>:
        gc_debug_file.0 = gc_debug_file;
        D.19199 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19199, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.19201>:
        <D.19198>:
        <D.19196>:
      }
      <D.19194>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.19068>:
      if (_bmap != 0) goto <D.19067>; else goto <D.19069>;
      <D.19069>:
      start_run = start_run + 512;
    }
    <D.19071>:
    bwords.3 = bwords;
    bwords = bwords.3 + -1;
    if (bwords.3 > 0) goto <D.19070>; else goto <D.19072>;
    <D.19072>:
  }
  goto <D.19008>;
  <D.19073>:
  goto <D.19008>;
  <D.19074>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.19008>:
}


split_nursery_serial_copy_object_from_obj (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.4;
  int D.19207;
  struct FILE * gc_debug_file.5;
  char * iftmp.6;
  long unsigned int D.19214;
  long unsigned int D.19215;
  long unsigned int D.19218;
  int iftmp.7;
  int D.19229;
  int D.19231;
  _Bool D.19233;
  long int D.19234;
  long int D.19235;
  long unsigned int D.19238;
  _Bool D.19239;
  long int D.19240;
  long int D.19241;
  int D.19248;
  int D.19251;
  int D.19258;
  int iftmp.8;
  int D.19264;
  int D.19266;
  _Bool D.19268;
  long int D.19269;
  long int D.19270;
  char * forwarded;
  char * obj;
  void * copy;

  obj = *obj_slot;
  if (0 != 0) goto <D.19204>; else goto <D.19205>;
  <D.19204>:
  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.18676>:
  goto <D.18676>;
  <D.19205>:
  D.19207 = sgen_ptr_in_nursery (obj);
  if (D.19207 == 0) goto <D.19208>; else goto <D.19209>;
  <D.19208>:
  return;
  <D.19209>:
  if (0 != 0) goto <D.19210>; else goto <D.19211>;
  <D.19210>:
  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.19211>:
  D.19214 = MEM[(mword *)obj];
  D.19215 = D.19214 & 1;
  if (D.19215 != 0) goto <D.19216>; else goto <D.19217>;
  <D.19216>:
  D.19214 = MEM[(mword *)obj];
  D.19218 = D.19214 & 18446744073709551612;
  iftmp.6 = (char *) D.19218;
  goto <D.19219>;
  <D.19217>:
  iftmp.6 = 0B;
  <D.19219>:
  forwarded = iftmp.6;
  if (forwarded != 0B) goto <D.19220>; else goto <D.19221>;
  <D.19220>:
  if (0 != 0) goto <D.19222>; else goto <D.19223>;
  <D.19222>:
  monoeg_g_log (0B, 4, "forwarded object %p has no gc descriptor", forwarded);
  <D.18677>:
  goto <D.18677>;
  <D.19223>:
  if (0 != 0) goto <D.19224>; else goto <D.19225>;
  <D.19224>:
  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.19225>:
  *obj_slot = forwarded;
  D.19229 = sgen_ptr_in_nursery (forwarded);
  if (D.19229 != 0) goto <D.19230>; else goto <D.19227>;
  <D.19230>:
  D.19231 = sgen_ptr_in_nursery (obj_slot);
  if (D.19231 == 0) goto <D.19232>; else goto <D.19227>;
  <D.19232>:
  iftmp.7 = 1;
  goto <D.19228>;
  <D.19227>:
  iftmp.7 = 0;
  <D.19228>:
  D.19233 = iftmp.7 != 0;
  D.19234 = (long int) D.19233;
  D.19235 = __builtin_expect (D.19234, 0);
  if (D.19235 != 0) goto <D.19236>; else goto <D.19237>;
  <D.19236>:
  sgen_add_to_global_remset (obj_slot, forwarded);
  <D.19237>:
  return;
  <D.19221>:
  D.19214 = MEM[(mword *)obj];
  D.19238 = D.19214 & 2;
  D.19239 = D.19238 != 0;
  D.19240 = (long int) D.19239;
  D.19241 = __builtin_expect (D.19240, 0);
  if (D.19241 != 0) goto <D.19242>; else goto <D.19243>;
  <D.19242>:
  if (0 != 0) goto <D.19244>; else goto <D.19245>;
  <D.19244>:
  monoeg_g_log (0B, 4, "pinned object %p has no gc descriptor", obj);
  <D.18678>:
  goto <D.18678>;
  <D.19245>:
  if (0 != 0) goto <D.19246>; else goto <D.19247>;
  <D.19246>:
  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.19247>:
  D.19248 = sgen_ptr_in_nursery (obj_slot);
  if (D.19248 == 0) goto <D.19249>; else goto <D.19250>;
  <D.19249>:
  sgen_add_to_global_remset (obj_slot, obj);
  <D.19250>:
  return;
  <D.19243>:
  D.19251 = sgen_nursery_is_to_space (obj);
  if (D.19251 != 0) goto <D.19252>; else goto <D.19253>;
  <D.19252>:
  if (0 != 0) goto <D.19254>; else goto <D.19255>;
  <D.19254>:
  monoeg_g_log (0B, 4, "to space object %p has no gc descriptor", obj);
  <D.18679>:
  goto <D.18679>;
  <D.19255>:
  if (0 != 0) goto <D.19256>; else goto <D.19257>;
  <D.19256>:
  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.19257>:
  D.19258 = sgen_ptr_in_nursery (obj_slot);
  if (D.19258 == 0) goto <D.19259>; else goto <D.19260>;
  <D.19259>:
  sgen_add_to_global_remset (obj_slot, obj);
  <D.19260>:
  return;
  <D.19253>:
  copy = copy_object_no_checks (obj, queue);
  *obj_slot = copy;
  D.19264 = sgen_ptr_in_nursery (copy);
  if (D.19264 != 0) goto <D.19265>; else goto <D.19262>;
  <D.19265>:
  D.19266 = sgen_ptr_in_nursery (obj_slot);
  if (D.19266 == 0) goto <D.19267>; else goto <D.19262>;
  <D.19267>:
  iftmp.8 = 1;
  goto <D.19263>;
  <D.19262>:
  iftmp.8 = 0;
  <D.19263>:
  D.19268 = iftmp.8 != 0;
  D.19269 = (long int) D.19268;
  D.19270 = __builtin_expect (D.19269, 0);
  if (D.19270 != 0) goto <D.19271>; else goto <D.19272>;
  <D.19271>:
  sgen_add_to_global_remset (obj_slot, copy);
  <D.19272>:
}


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.19277;
  long int D.19278;
  int D.19279;
  _Bool D.19280;
  long int D.19281;
  long int D.19282;
  char * D.19285;
  char * D.19286;
  int sgen_space_bitmap_size.12;
  _Bool D.19288;
  long int D.19289;
  long int D.19290;
  gboolean D.19293;
  char * sgen_space_bitmap.13;
  sizetype D.19295;
  char * D.19296;
  char D.19297;
  int D.19298;
  int D.19299;
  int D.19300;
  _Bool D.19301;
  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.19277 = object.9 - sgen_nursery_start.11;
  D.19278 = D.19277 >> 9;
  idx = (int) D.19278;
  byte = idx / 8;
  bit = idx & 7;
  D.19279 = sgen_ptr_in_nursery (object);
  D.19280 = D.19279 == 0;
  D.19281 = (long int) D.19280;
  D.19282 = __builtin_expect (D.19281, 0);
  if (D.19282 != 0) goto <D.19283>; else goto <D.19284>;
  <D.19283>:
  D.19285 = sgen_get_nursery_start ();
  D.19286 = sgen_get_nursery_end ();
  monoeg_g_log (0B, 4, "object %p is not in nursery [%p - %p]", object, D.19285, D.19286);
  <D.17962>:
  goto <D.17962>;
  <D.19284>:
  sgen_space_bitmap_size.12 = sgen_space_bitmap_size;
  D.19288 = byte >= sgen_space_bitmap_size.12;
  D.19289 = (long int) D.19288;
  D.19290 = __builtin_expect (D.19289, 0);
  if (D.19290 != 0) goto <D.19291>; else goto <D.19292>;
  <D.19291>:
  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.17963>:
  goto <D.17963>;
  <D.19292>:
  sgen_space_bitmap.13 = sgen_space_bitmap;
  D.19295 = (sizetype) byte;
  D.19296 = sgen_space_bitmap.13 + D.19295;
  D.19297 = *D.19296;
  D.19298 = (int) D.19297;
  D.19299 = D.19298 >> bit;
  D.19300 = D.19299 & 1;
  D.19301 = D.19300 != 0;
  D.19293 = (gboolean) D.19301;
  return D.19293;
}


sgen_get_nursery_start ()
{
  char * D.19303;

  D.19303 = sgen_nursery_start;
  return D.19303;
}


sgen_get_nursery_end ()
{
  char * D.19305;

  D.19305 = sgen_nursery_end;
  return D.19305;
}


copy_object_no_checks (void * obj, struct SgenGrayQueue * queue)
{
  void * D.19307;
  long unsigned int D.19308;
  unsigned int D.19309;
  unsigned int D.19310;
  long unsigned int D.19311;
  _Bool D.19312;
  long int D.19313;
  long int D.19314;
  void * D.19317;
  struct SgenGrayQueue * iftmp.14;
  long unsigned int destination.15;
  long unsigned int D.19323;
  struct MonoVTable * vt;
  gboolean has_references;
  mword objsize;
  char * destination;

  vt = MEM[(struct MonoObject *)obj].vtable;
  D.19307 = vt->gc_descr;
  D.19308 = (long unsigned int) D.19307;
  has_references = sgen_gc_descr_has_references (D.19308);
  D.19309 = sgen_par_object_get_size (vt, obj);
  D.19310 = D.19309 + 7;
  D.19311 = (long unsigned int) D.19310;
  objsize = D.19311 & 4294967288;
  destination = alloc_for_promotion (vt, obj, objsize, has_references);
  D.19312 = destination == 0B;
  D.19313 = (long int) D.19312;
  D.19314 = __builtin_expect (D.19313, 0);
  if (D.19314 != 0) goto <D.19315>; else goto <D.19316>;
  <D.19315>:
  sgen_pin_object (obj, queue);
  sgen_set_pinned_from_failed_allocation (objsize);
  D.19317 = obj;
  return D.19317;
  <D.19316>:
  if (has_references != 0) goto <D.19319>; else goto <D.19320>;
  <D.19319>:
  iftmp.14 = queue;
  goto <D.19321>;
  <D.19320>:
  iftmp.14 = 0B;
  <D.19321>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.14);
  destination.15 = (long unsigned int) destination;
  D.19323 = destination.15 | 1;
  MEM[(mword *)obj] = D.19323;
  D.19317 = destination;
  return D.19317;
}


sgen_gc_descr_has_references (mword desc)
{
  long unsigned int D.19325;
  gboolean D.19328;
  long unsigned int D.19329;
  long unsigned int D.19332;

  D.19325 = desc & 4294901767;
  if (D.19325 == 1) goto <D.19326>; else goto <D.19327>;
  <D.19326>:
  D.19328 = 0;
  return D.19328;
  <D.19327>:
  D.19329 = desc & 49159;
  if (D.19329 == 4) goto <D.19330>; else goto <D.19331>;
  <D.19330>:
  D.19328 = 0;
  return D.19328;
  <D.19331>:
  D.19332 = desc & 7;
  if (D.19332 == 7) goto <D.19333>; else goto <D.19334>;
  <D.19333>:
  D.19328 = 0;
  return D.19328;
  <D.19334>:
  D.19328 = 1;
  return D.19328;
}


sgen_par_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  void * D.19336;
  long unsigned int D.19337;
  guint D.19342;
  int D.19343;
  int D.19344;
  unsigned int D.19345;
  long unsigned int D.19348;
  int D.19349;
  unsigned int D.19350;
  unsigned int element_size.16;
  unsigned int D.19352;
  long unsigned int D.19353;
  long unsigned int D.19354;
  struct MonoClass * D.19357;
  unsigned char D.19358;
  long unsigned int D.19359;
  long unsigned int D.19360;
  mword descr;
  mword type;

  D.19336 = vtable->gc_descr;
  descr = (mword) D.19336;
  type = descr & 7;
  D.19337 = type + 18446744073709551615;
  if (D.19337 <= 1) goto <D.19338>; else goto <D.19339>;
  <D.19338>:
  {
    mword size;

    size = descr & 65528;
    if (size == 0) goto <D.19340>; else goto <D.19341>;
    <D.19340>:
    D.19343 = MEM[(struct MonoString *)o].length;
    D.19344 = D.19343 * 2;
    D.19345 = (unsigned int) D.19344;
    D.19342 = D.19345 + 26;
    return D.19342;
    <D.19341>:
    D.19342 = (guint) size;
    return D.19342;
  }
  <D.19339>:
  if (type == 4) goto <D.19346>; else goto <D.19347>;
  <D.19346>:
  {
    int element_size;
    struct MonoArray * array;
    size_t size;

    D.19348 = descr >> 3;
    D.19349 = (int) D.19348;
    element_size = D.19349 & 1023;
    array = o;
    D.19350 = array->max_length;
    element_size.16 = (unsigned int) element_size;
    D.19352 = D.19350 * element_size.16;
    D.19353 = (long unsigned int) D.19352;
    size = D.19353 + 32;
    D.19354 = descr & 8192;
    if (D.19354 != 0) goto <D.19355>; else goto <D.19356>;
    <D.19355>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.19357 = vtable->klass;
    D.19358 = D.19357->rank;
    D.19359 = (long unsigned int) D.19358;
    D.19360 = D.19359 * 8;
    size = D.19360 + size;
    <D.19356>:
    D.19342 = (guint) size;
    return D.19342;
  }
  <D.19347>:
  D.19342 = slow_object_get_size (vtable, o);
  return D.19342;
}


slow_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  struct MonoClass * D.19362;
  guint D.19365;
  int D.19366;
  int D.19367;
  unsigned int D.19368;
  unsigned char D.19369;
  int D.19372;
  unsigned int D.19373;
  unsigned int D.19374;
  unsigned int D.19375;
  long unsigned int D.19376;
  struct MonoArrayBounds * D.19377;
  _Bool D.19378;
  long int D.19379;
  long int D.19380;
  long unsigned int D.19383;
  long unsigned int D.19384;
  int D.19385;
  struct MonoClass * klass;

  klass = vtable->klass;
  D.19362 = mono_defaults.string_class;
  if (D.19362 == klass) goto <D.19363>; else goto <D.19364>;
  <D.19363>:
  D.19366 = MEM[(struct MonoString *)o].length;
  D.19367 = D.19366 * 2;
  D.19368 = (unsigned int) D.19367;
  D.19365 = D.19368 + 26;
  return D.19365;
  <D.19364>:
  D.19369 = klass->rank;
  if (D.19369 != 0) goto <D.19370>; else goto <D.19371>;
  <D.19370>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.19372 = klass->sizes.element_size;
    D.19373 = (unsigned int) D.19372;
    D.19374 = array->max_length;
    D.19375 = D.19373 * D.19374;
    D.19376 = (long unsigned int) D.19375;
    size = D.19376 + 32;
    D.19377 = array->bounds;
    D.19378 = D.19377 != 0B;
    D.19379 = (long int) D.19378;
    D.19380 = __builtin_expect (D.19379, 0);
    if (D.19380 != 0) goto <D.19381>; else goto <D.19382>;
    <D.19381>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.19369 = klass->rank;
    D.19383 = (long unsigned int) D.19369;
    D.19384 = D.19383 * 8;
    size = D.19384 + size;
    <D.19382>:
    D.19365 = (guint) size;
    return D.19365;
  }
  <D.19371>:
  D.19385 = klass->instance_size;
  D.19365 = (guint) D.19385;
  return D.19365;
}


alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int promote_age.17;
  char * D.19390;
  void * (*<T2f12>) (struct MonoVTable *, int, gboolean) D.19391;
  int D.19392;
  char * D.19393;
  char * D.19394;
  _Bool D.19395;
  long int D.19396;
  long int D.19397;
  char * D.19400;
  char * D.19401;
  char * p;
  int age;

  p = 0B;
  age = get_object_age (obj);
  promote_age.17 = promote_age;
  if (age >= promote_age.17) goto <D.19388>; else goto <D.19389>;
  <D.19388>:
  D.19391 = major_collector.alloc_object;
  D.19392 = (int) objsize;
  D.19390 = D.19391 (vtable, D.19392, has_references);
  return D.19390;
  <D.19389>:
  age = age + 1;
  p = age_alloc_buffers[age].next;
  D.19393 = p + objsize;
  D.19394 = age_alloc_buffers[age].end;
  D.19395 = D.19393 <= D.19394;
  D.19396 = (long int) D.19395;
  D.19397 = __builtin_expect (D.19396, 1);
  if (D.19397 != 0) goto <D.19398>; else goto <D.19399>;
  <D.19398>:
  D.19400 = age_alloc_buffers[age].next;
  D.19401 = D.19400 + objsize;
  age_alloc_buffers[age].next = D.19401;
  goto <D.19402>;
  <D.19399>:
  p = alloc_for_promotion_slow_path (age, objsize);
  if (p == 0B) goto <D.19403>; else goto <D.19404>;
  <D.19403>:
  D.19391 = major_collector.alloc_object;
  D.19392 = (int) objsize;
  D.19390 = D.19391 (vtable, D.19392, has_references);
  return D.19390;
  <D.19404>:
  <D.19402>:
  MEM[(struct MonoVTable * *)p] = vtable;
  D.19390 = p;
  return D.19390;
}


get_object_age (char * object)
{
  long int object.18;
  char * sgen_nursery_start.19;
  long int sgen_nursery_start.20;
  long int D.19409;
  long int D.19410;
  int D.19411;
  char * region_age.21;
  sizetype D.19413;
  char * D.19414;
  char D.19415;
  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.19409 = object.18 - sgen_nursery_start.20;
  D.19410 = D.19409 >> 9;
  idx = (int) D.19410;
  region_age.21 = region_age;
  D.19413 = (sizetype) idx;
  D.19414 = region_age.21 + D.19413;
  D.19415 = *D.19414;
  D.19411 = (int) D.19415;
  return D.19411;
}


alloc_for_promotion_slow_path (int age, size_t objsize)
{
  long unsigned int D.19417;
  long unsigned int D.19418;
  long unsigned int D.19419;
  long unsigned int allocated_size.22;
  char * D.19423;
  char * D.19424;
  char * D.19425;
  char * D.19426;
  char * D.19427;
  char * p;
  size_t allocated_size;
  size_t aligned_objsize;

  try
    {
      D.19417 = objsize + 511;
      aligned_objsize = D.19417 & 18446744073709551104;
      D.19418 = MAX_EXPR <aligned_objsize, 4096>;
      D.19419 = MAX_EXPR <aligned_objsize, 512>;
      p = sgen_fragment_allocator_serial_range_alloc (&collector_allocator, D.19418, D.19419, &allocated_size);
      if (p != 0B) goto <D.19420>; else goto <D.19421>;
      <D.19420>:
      allocated_size.22 = allocated_size;
      D.19423 = p + allocated_size.22;
      set_age_in_range (p, D.19423, age);
      D.19424 = age_alloc_buffers[age].next;
      D.19425 = age_alloc_buffers[age].end;
      sgen_clear_range (D.19424, D.19425);
      D.19426 = p + objsize;
      age_alloc_buffers[age].next = D.19426;
      allocated_size.22 = allocated_size;
      D.19423 = p + allocated_size.22;
      age_alloc_buffers[age].end = D.19423;
      <D.19421>:
      D.19427 = p;
      return D.19427;
    }
  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.19433;
  long int D.19434;
  char * region_age.26;
  sizetype D.19436;
  long int end.27;
  long int D.19438;
  long int D.19439;
  long unsigned int D.19440;
  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.19433 = start.23 - sgen_nursery_start.25;
  D.19434 = D.19433 >> 9;
  region_idx = (int) D.19434;
  region_age.26 = region_age;
  D.19436 = (sizetype) region_idx;
  region_start = region_age.26 + D.19436;
  end.27 = (long int) end;
  start.23 = (long int) start;
  D.19438 = end.27 - start.23;
  D.19439 = D.19438 >> 9;
  length = (int) D.19439;
  D.19440 = (long unsigned int) length;
  memset (region_start, age, D.19440);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.19443;
  int D.19448;
  void * D.19450;
  long unsigned int D.19451;

  D.19443 = __builtin_constant_p (__len);
  if (D.19443 != 0) goto <D.19444>; else goto <D.19445>;
  <D.19444>:
  if (__len == 0) goto <D.19446>; else goto <D.19447>;
  <D.19446>:
  D.19448 = __builtin_constant_p (__ch);
  if (D.19448 == 0) goto <D.19441>; else goto <D.19449>;
  <D.19449>:
  if (__ch != 0) goto <D.19441>; else goto <D.19442>;
  <D.19441>:
  __warn_memset_zero_len ();
  D.19450 = __dest;
  return D.19450;
  <D.19442>:
  <D.19447>:
  <D.19445>:
  D.19451 = __builtin_object_size (__dest, 0);
  D.19450 = __builtin___memset_chk (__dest, __ch, __len, D.19451);
  return D.19450;
}


par_copy_object_no_checks (char * destination, struct MonoVTable * vt, void * obj, mword objsize, struct SgenGrayQueue * queue)
{
  struct MonoClass * D.19455;
  const char * D.19456;
  const char * D.19457;
  struct FILE * gc_debug_file.28;
  struct MonoVTable * D.19461;
  struct MonoClass * D.19462;
  const char * D.19463;
  long unsigned int D.19466;
  const void * D.19467;
  mword * D.19468;
  long unsigned int D.19469;
  mword * D.19470;
  long unsigned int D.19471;
  mword * D.19472;
  long unsigned int D.19473;
  mword * D.19474;
  long unsigned int D.19475;
  mword * D.19476;
  long unsigned int D.19477;
  mword * D.19478;
  long unsigned int D.19479;
  mword * D.19480;
  long unsigned int D.19481;
  void * D.19483;
  const void * D.19484;
  long unsigned int D.19485;
  int iftmp.29;
  unsigned char D.19491;
  struct MonoArrayBounds * D.19493;
  _Bool D.19495;
  long int D.19496;
  long int D.19497;
  long int D.19500;
  long int obj.30;
  long int D.19502;
  sizetype D.19503;
  struct MonoArrayBounds * D.19504;
  int D.19507;
  long unsigned int D.19508;
  <unnamed type> mono_profiler_events.31;
  unsigned int D.19510;
  _Bool D.19511;
  long int D.19512;
  long int D.19513;
  const char * D.19520;
  int iftmp.32;
  struct GrayQueueSection * D.19525;
  int D.19527;
  _Bool D.19528;
  long int D.19529;
  long int D.19530;
  int D.19534;
  int D.19535;
  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.19453>; else goto <D.19454>;
  <D.19453>:
  D.19455 = vt->klass;
  D.19456 = D.19455->name_space;
  D.19455 = vt->klass;
  D.19457 = D.19455->name;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s was not initialized", vt, D.19456, D.19457);
  <D.18647>:
  goto <D.18647>;
  <D.19454>:
  if (0 != 0) goto <D.19458>; else goto <D.19459>;
  <D.19458>:
  gc_debug_file.28 = gc_debug_file;
  D.19461 = MEM[(struct MonoObject *)obj].vtable;
  D.19462 = D.19461->klass;
  D.19463 = D.19462->name;
  fprintf (gc_debug_file.28, " (to %p, %s size: %lu)\n", destination, D.19463, objsize);
  gc_debug_file.28 = gc_debug_file;
  fflush (gc_debug_file.28);
  <D.19459>:
  if (objsize <= 64) goto <D.19464>; else goto <D.19465>;
  <D.19464>:
  {
    mword * dest;

    dest = destination;
    D.19466 = objsize / 8;
    D.19467 = copy_labels[D.19466];
    goto D.19467;
    LAB_8:
    D.19468 = dest + 56;
    D.19469 = MEM[(mword *)obj + 56B];
    *D.19468 = D.19469;
    LAB_7:
    D.19470 = dest + 48;
    D.19471 = MEM[(mword *)obj + 48B];
    *D.19470 = D.19471;
    LAB_6:
    D.19472 = dest + 40;
    D.19473 = MEM[(mword *)obj + 40B];
    *D.19472 = D.19473;
    LAB_5:
    D.19474 = dest + 32;
    D.19475 = MEM[(mword *)obj + 32B];
    *D.19474 = D.19475;
    LAB_4:
    D.19476 = dest + 24;
    D.19477 = MEM[(mword *)obj + 24B];
    *D.19476 = D.19477;
    LAB_3:
    D.19478 = dest + 16;
    D.19479 = MEM[(mword *)obj + 16B];
    *D.19478 = D.19479;
    LAB_2:
    D.19480 = dest + 8;
    D.19481 = MEM[(mword *)obj + 8B];
    *D.19480 = D.19481;
    LAB_1:
    LAB_0:
  }
  goto <D.19482>;
  <D.19465>:
  D.19483 = destination + 8;
  D.19484 = obj + 8;
  D.19485 = objsize + 18446744073709551608;
  mono_gc_memmove_aligned (D.19483, D.19484, D.19485);
  <D.19482>:
  if (0 != 0) goto <D.19486>; else goto <D.19487>;
  <D.19486>:
  D.19455 = vt->klass;
  D.19456 = D.19455->name_space;
  D.19455 = vt->klass;
  D.19457 = D.19455->name;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s has no gc descriptor", vt, D.19456, D.19457);
  <D.18649>:
  goto <D.18649>;
  <D.19487>:
  D.19491 = vt->rank;
  if (D.19491 != 0) goto <D.19492>; else goto <D.19489>;
  <D.19492>:
  D.19493 = MEM[(struct MonoArray *)obj].bounds;
  if (D.19493 != 0B) goto <D.19494>; else goto <D.19489>;
  <D.19494>:
  iftmp.29 = 1;
  goto <D.19490>;
  <D.19489>:
  iftmp.29 = 0;
  <D.19490>:
  D.19495 = iftmp.29 != 0;
  D.19496 = (long int) D.19495;
  D.19497 = __builtin_expect (D.19496, 0);
  if (D.19497 != 0) goto <D.19498>; else goto <D.19499>;
  <D.19498>:
  {
    struct MonoArray * array;

    array = destination;
    D.19493 = MEM[(struct MonoArray *)obj].bounds;
    D.19500 = (long int) D.19493;
    obj.30 = (long int) obj;
    D.19502 = D.19500 - obj.30;
    D.19503 = (sizetype) D.19502;
    D.19504 = destination + D.19503;
    array->bounds = D.19504;
    if (0 != 0) goto <D.19505>; else goto <D.19506>;
    <D.19505>:
    gc_debug_file.28 = gc_debug_file;
    D.19491 = vt->rank;
    D.19507 = (int) D.19491;
    D.19508 = mono_array_length (array);
    fprintf (gc_debug_file.28, "Array instance %p: size: %lu, rank: %d, length: %lu\n", array, objsize, D.19507, D.19508);
    gc_debug_file.28 = gc_debug_file;
    fflush (gc_debug_file.28);
    <D.19506>:
  }
  <D.19499>:
  mono_profiler_events.31 = mono_profiler_events;
  D.19510 = mono_profiler_events.31 & 524288;
  D.19511 = D.19510 != 0;
  D.19512 = (long int) D.19511;
  D.19513 = __builtin_expect (D.19512, 0);
  if (D.19513 != 0) goto <D.19514>; else goto <D.19515>;
  <D.19514>:
  sgen_register_moved_object (obj, destination);
  <D.19515>:
  obj = destination;
  if (queue != 0B) goto <D.19516>; else goto <D.19517>;
  <D.19516>:
  if (0 != 0) goto <D.19518>; else goto <D.19519>;
  <D.19518>:
  gc_debug_file.28 = gc_debug_file;
  D.19520 = sgen_safe_name (obj);
  fprintf (gc_debug_file.28, "Enqueuing gray object %p (%s)\n", obj, D.19520);
  gc_debug_file.28 = gc_debug_file;
  fflush (gc_debug_file.28);
  <D.19519>:
  D.19525 = queue->first;
  if (D.19525 == 0B) goto <D.19522>; else goto <D.19526>;
  <D.19526>:
  D.19525 = queue->first;
  D.19527 = D.19525->end;
  if (D.19527 == 125) goto <D.19522>; else goto <D.19523>;
  <D.19522>:
  iftmp.32 = 1;
  goto <D.19524>;
  <D.19523>:
  iftmp.32 = 0;
  <D.19524>:
  D.19528 = iftmp.32 != 0;
  D.19529 = (long int) D.19528;
  D.19530 = __builtin_expect (D.19529, 0);
  if (D.19530 != 0) goto <D.19531>; else goto <D.19532>;
  <D.19531>:
  sgen_gray_object_enqueue (queue, obj);
  goto <D.19533>;
  <D.19532>:
  D.19525 = queue->first;
  D.19525 = queue->first;
  D.19527 = D.19525->end;
  D.19534 = D.19527;
  D.19535 = D.19534 + 1;
  D.19525->end = D.19535;
  D.19525->objects[D.19534] = obj;
  <D.19533>:
  __builtin_prefetch (obj);
  <D.19517>:
}


sgen_ptr_in_nursery (void * p)
{
  gboolean D.19538;
  int sgen_nursery_bits.34;
  int D.19540;
  int D.19541;
  long unsigned int D.19542;
  long unsigned int p.35;
  long unsigned int D.19544;
  char * sgen_nursery_start.36;
  long unsigned int sgen_nursery_start.37;
  _Bool D.19547;

  sgen_nursery_bits.34 = sgen_nursery_bits;
  D.19540 = 1 << sgen_nursery_bits.34;
  D.19541 = -D.19540;
  D.19542 = (long unsigned int) D.19541;
  p.35 = (long unsigned int) p;
  D.19544 = D.19542 & p.35;
  sgen_nursery_start.36 = sgen_nursery_start;
  sgen_nursery_start.37 = (long unsigned int) sgen_nursery_start.36;
  D.19547 = D.19544 == sgen_nursery_start.37;
  D.19538 = (gboolean) D.19547;
  return D.19538;
}


split_nursery_serial_scan_object (char * start, struct SgenGrayQueue * queue)
{
  long unsigned int D.19549;
  long unsigned int D.19550;
  long unsigned int D.19551;
  long unsigned int D.19552;
  long unsigned int D.19555;
  long unsigned int D.19556;
  long unsigned int D.19557;
  long unsigned int D.19558;
  long unsigned int D.19559;
  long unsigned int D.19560;
  void * D.19565;
  struct FILE * gc_debug_file.38;
  long unsigned int D.19575;
  long unsigned int D.19576;
  int D.19577;
  void * D.19582;
  long unsigned int D.19585;
  long unsigned int D.19586;
  int D.19587;
  long unsigned int D.19594;
  long unsigned int D.19597;
  int D.19598;
  int D.19599;
  unsigned int D.19602;
  unsigned int el_size.39;
  unsigned int D.19604;
  sizetype D.19605;
  void * D.19610;
  int D.19616;
  int D.19617;
  long unsigned int D.19618;
  long unsigned int D.19619;
  long unsigned int D.19620;
  long unsigned int D.19621;
  void * * D.19622;
  void * D.19627;
  sizetype D.19630;
  long unsigned int D.19634;
  void * D.19641;
  long unsigned int D.19644;
  void * D.19651;
  long unsigned int D.19654;
  unsigned int D.19655;
  unsigned int D.19656;
  struct MonoVTable * D.19659;
  struct MonoClass * D.19660;
  const char * D.19661;
  const char * D.19662;
  gsize * bitmap_data.40;
  long unsigned int D.19664;
  void * D.19671;
  int bwords.41;
  long unsigned int D.19675;
  gsize * mbitmap_data.42;
  long unsigned int D.19677;
  unsigned int D.19678;
  unsigned int D.19679;
  struct MonoClass * D.19680;
  unsigned int el_size.43;
  unsigned int D.19682;
  sizetype D.19683;
  const char * D.19686;
  const char * D.19687;
  gsize * bitmap_data.44;
  long unsigned int D.19689;
  void * D.19696;
  unsigned int bwords.45;
  sizetype D.19700;

  {
    struct GCVTable * vt;
    mword desc;

    D.19549 = MEM[(mword *)start];
    D.19550 = D.19549 & 18446744073709551612;
    vt = (struct GCVTable *) D.19550;
    desc = vt->desc;
    D.19551 = desc & 7;
    switch (D.19551) <default: <D.18994>, case 1: <D.18899>, case 2: <D.18908>, case 3: <D.18958>, case 4: <D.18918>, case 5: <D.18951>, case 6: <D.18972>, case 7: <D.18993>>
    <D.18899>:
    D.19552 = desc & 4294901760;
    if (D.19552 != 0) goto <D.19553>; else goto <D.19554>;
    <D.19553>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19555 = desc >> 16;
      D.19556 = D.19555 & 255;
      D.19557 = D.19556 * 8;
      _objptr = _objptr + D.19557;
      D.19558 = desc >> 24;
      D.19559 = D.19558 & 255;
      D.19560 = D.19559 * 8;
      _objptr_end = _objptr + D.19560;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19561>; else goto <D.19562>;
        <D.19561>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19563>; else goto <D.19564>;
        <D.19563>:
        D.19565 = *_objptr;
        if (D.19565 != __old) goto <D.19566>; else goto <D.19567>;
        <D.19566>:
        gc_debug_file.38 = gc_debug_file;
        D.19565 = *_objptr;
        fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19565, __old);
        gc_debug_file.38 = gc_debug_file;
        fflush (gc_debug_file.38);
        <D.19567>:
        <D.19564>:
        <D.19562>:
      }
      _objptr = _objptr + 8;
      goto <D.18905>;
      <D.18904>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19569>; else goto <D.19570>;
        <D.19569>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19571>; else goto <D.19572>;
        <D.19571>:
        D.19565 = *_objptr;
        if (D.19565 != __old) goto <D.19573>; else goto <D.19574>;
        <D.19573>:
        gc_debug_file.38 = gc_debug_file;
        D.19565 = *_objptr;
        fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19565, __old);
        gc_debug_file.38 = gc_debug_file;
        fflush (gc_debug_file.38);
        <D.19574>:
        <D.19572>:
        <D.19570>:
      }
      _objptr = _objptr + 8;
      <D.18905>:
      if (_objptr < _objptr_end) goto <D.18904>; else goto <D.18906>;
      <D.18906>:
    }
    <D.19554>:
    goto <D.18907>;
    <D.18908>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.19575 = (long unsigned int) _index;
        D.19576 = D.19575 * 8;
        _objptr = _objptr + D.19576;
        D.19577 = _index + 1;
        _bmap = _bmap >> D.19577;
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.19578>; else goto <D.19579>;
          <D.19578>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.19580>; else goto <D.19581>;
          <D.19580>:
          D.19582 = *_objptr;
          if (D.19582 != __old) goto <D.19583>; else goto <D.19584>;
          <D.19583>:
          gc_debug_file.38 = gc_debug_file;
          D.19582 = *_objptr;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19582, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19584>:
          <D.19581>:
          <D.19579>:
        }
        _objptr = _objptr + 8;
      }
      goto <D.18916>;
      <D.18915>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.19585 = (long unsigned int) _index;
        D.19586 = D.19585 * 8;
        _objptr = _objptr + D.19586;
        D.19587 = _index + 1;
        _bmap = _bmap >> D.19587;
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.19588>; else goto <D.19589>;
          <D.19588>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.19590>; else goto <D.19591>;
          <D.19590>:
          D.19582 = *_objptr;
          if (D.19582 != __old) goto <D.19592>; else goto <D.19593>;
          <D.19592>:
          gc_debug_file.38 = gc_debug_file;
          D.19582 = *_objptr;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19582, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19593>:
          <D.19591>:
          <D.19589>:
        }
        _objptr = _objptr + 8;
      }
      <D.18916>:
      if (_bmap != 0) goto <D.18915>; else goto <D.18917>;
      <D.18917>:
    }
    goto <D.18907>;
    <D.18918>:
    D.19594 = desc & 4294950912;
    if (D.19594 != 0) goto <D.19595>; else goto <D.19596>;
    <D.19595>:
    {
      int el_size;
      int etype;

      D.19597 = desc >> 3;
      D.19598 = (int) D.19597;
      el_size = D.19598 & 1023;
      D.19599 = (int) desc;
      etype = D.19599 & 49152;
      if (etype == 16384) goto <D.19600>; else goto <D.19601>;
      <D.19600>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.19602 = MEM[(struct MonoArray *)start].max_length;
        el_size.39 = (unsigned int) el_size;
        D.19604 = D.19602 * el_size.39;
        D.19605 = (sizetype) D.19604;
        end_refs = p + D.19605;
        goto <D.18925>;
        <D.18924>:
        {
          void * __old;

          __old = *p;
          if (__old != 0B) goto <D.19606>; else goto <D.19607>;
          <D.19606>:
          split_nursery_serial_copy_object_from_obj (p, queue);
          if (0 != 0) goto <D.19608>; else goto <D.19609>;
          <D.19608>:
          D.19610 = *p;
          if (D.19610 != __old) goto <D.19611>; else goto <D.19612>;
          <D.19611>:
          gc_debug_file.38 = gc_debug_file;
          D.19610 = *p;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", p, D.19610, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19612>:
          <D.19609>:
          <D.19607>:
        }
        p = p + 8;
        <D.18925>:
        if (p < end_refs) goto <D.18924>; else goto <D.18926>;
        <D.18926>:
      }
      goto <D.19613>;
      <D.19601>:
      if (etype == 32768) goto <D.19614>; else goto <D.19615>;
      <D.19614>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19555 = desc >> 16;
        D.19616 = (int) D.19555;
        offset = D.19616 & 255;
        D.19558 = desc >> 24;
        D.19617 = (int) D.19558;
        num_refs = D.19617 & 255;
        e_start = start + 32;
        D.19602 = MEM[(struct MonoArray *)start].max_length;
        el_size.39 = (unsigned int) el_size;
        D.19604 = D.19602 * el_size.39;
        D.19605 = (sizetype) D.19604;
        e_end = e_start + D.19605;
        goto <D.18938>;
        <D.18937>:
        {
          void * * p;
          int i;

          p = e_start;
          D.19618 = (long unsigned int) offset;
          D.19619 = D.19618 * 8;
          p = p + D.19619;
          i = 0;
          goto <D.18935>;
          <D.18934>:
          {
            void * __old;

            D.19620 = (long unsigned int) i;
            D.19621 = D.19620 * 8;
            D.19622 = p + D.19621;
            __old = *D.19622;
            if (__old != 0B) goto <D.19623>; else goto <D.19624>;
            <D.19623>:
            D.19620 = (long unsigned int) i;
            D.19621 = D.19620 * 8;
            D.19622 = p + D.19621;
            split_nursery_serial_copy_object_from_obj (D.19622, queue);
            if (0 != 0) goto <D.19625>; else goto <D.19626>;
            <D.19625>:
            D.19620 = (long unsigned int) i;
            D.19621 = D.19620 * 8;
            D.19622 = p + D.19621;
            D.19627 = *D.19622;
            if (D.19627 != __old) goto <D.19628>; else goto <D.19629>;
            <D.19628>:
            gc_debug_file.38 = gc_debug_file;
            D.19620 = (long unsigned int) i;
            D.19621 = D.19620 * 8;
            D.19622 = p + D.19621;
            D.19620 = (long unsigned int) i;
            D.19621 = D.19620 * 8;
            D.19622 = p + D.19621;
            D.19627 = *D.19622;
            fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", D.19622, D.19627, __old);
            gc_debug_file.38 = gc_debug_file;
            fflush (gc_debug_file.38);
            <D.19629>:
            <D.19626>:
            <D.19624>:
          }
          i = i + 1;
          <D.18935>:
          if (i < num_refs) goto <D.18934>; else goto <D.18936>;
          <D.18936>:
          D.19630 = (sizetype) el_size;
          e_start = e_start + D.19630;
        }
        <D.18938>:
        if (e_start < e_end) goto <D.18937>; else goto <D.18939>;
        <D.18939>:
      }
      goto <D.19631>;
      <D.19615>:
      if (etype == 49152) goto <D.19632>; else goto <D.19633>;
      <D.19632>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.19602 = MEM[(struct MonoArray *)start].max_length;
        el_size.39 = (unsigned int) el_size;
        D.19604 = D.19602 * el_size.39;
        D.19605 = (sizetype) D.19604;
        e_end = e_start + D.19605;
        goto <D.18949>;
        <D.18948>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.18946>;
          <D.18945>:
          D.19634 = _bmap & 1;
          if (D.19634 != 0) goto <D.19635>; else goto <D.19636>;
          <D.19635>:
          {
            void * __old;

            __old = *p;
            if (__old != 0B) goto <D.19637>; else goto <D.19638>;
            <D.19637>:
            split_nursery_serial_copy_object_from_obj (p, queue);
            if (0 != 0) goto <D.19639>; else goto <D.19640>;
            <D.19639>:
            D.19641 = *p;
            if (D.19641 != __old) goto <D.19642>; else goto <D.19643>;
            <D.19642>:
            gc_debug_file.38 = gc_debug_file;
            D.19641 = *p;
            fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", p, D.19641, __old);
            gc_debug_file.38 = gc_debug_file;
            fflush (gc_debug_file.38);
            <D.19643>:
            <D.19640>:
            <D.19638>:
          }
          <D.19636>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.18946>:
          if (_bmap != 0) goto <D.18945>; else goto <D.18947>;
          <D.18947>:
          D.19630 = (sizetype) el_size;
          e_start = e_start + D.19630;
        }
        <D.18949>:
        if (e_start < e_end) goto <D.18948>; else goto <D.18950>;
        <D.18950>:
      }
      <D.19633>:
      <D.19631>:
      <D.19613>:
    }
    <D.19596>:
    goto <D.18907>;
    <D.18951>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.18956>;
      <D.18955>:
      D.19644 = _bmap & 1;
      if (D.19644 != 0) goto <D.19645>; else goto <D.19646>;
      <D.19645>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19647>; else goto <D.19648>;
        <D.19647>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19649>; else goto <D.19650>;
        <D.19649>:
        D.19651 = *_objptr;
        if (D.19651 != __old) goto <D.19652>; else goto <D.19653>;
        <D.19652>:
        gc_debug_file.38 = gc_debug_file;
        D.19651 = *_objptr;
        fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19651, __old);
        gc_debug_file.38 = gc_debug_file;
        fflush (gc_debug_file.38);
        <D.19653>:
        <D.19650>:
        <D.19648>:
      }
      <D.19646>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18956>:
      if (_bmap != 0) goto <D.18955>; else goto <D.18957>;
      <D.18957>:
    }
    goto <D.18907>;
    <D.18958>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19654 = *bitmap_data;
      D.19655 = (unsigned int) D.19654;
      D.19656 = D.19655 + 4294967295;
      bwords = (int) D.19656;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.19657>; else goto <D.19658>;
      <D.19657>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19659 = myobj->vtable;
        D.19660 = D.19659->klass;
        D.19661 = D.19660->name_space;
        D.19659 = myobj->vtable;
        D.19660 = D.19659->klass;
        D.19662 = D.19660->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19661, D.19662);
      }
      <D.19658>:
      goto <D.18970>;
      <D.18969>:
      {
        gsize _bmap;

        bitmap_data.40 = bitmap_data;
        bitmap_data = bitmap_data.40 + 8;
        _bmap = *bitmap_data.40;
        _objptr = start_run;
        goto <D.18967>;
        <D.18966>:
        D.19664 = _bmap & 1;
        if (D.19664 != 0) goto <D.19665>; else goto <D.19666>;
        <D.19665>:
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.19667>; else goto <D.19668>;
          <D.19667>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.19669>; else goto <D.19670>;
          <D.19669>:
          D.19671 = *_objptr;
          if (D.19671 != __old) goto <D.19672>; else goto <D.19673>;
          <D.19672>:
          gc_debug_file.38 = gc_debug_file;
          D.19671 = *_objptr;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19671, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19673>:
          <D.19670>:
          <D.19668>:
        }
        <D.19666>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18967>:
        if (_bmap != 0) goto <D.18966>; else goto <D.18968>;
        <D.18968>:
        start_run = start_run + 512;
      }
      <D.18970>:
      bwords.41 = bwords;
      bwords = bwords.41 + -1;
      if (bwords.41 > 0) goto <D.18969>; else goto <D.18971>;
      <D.18971>:
    }
    goto <D.18907>;
    <D.18972>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19675 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19675);
      mbitmap_data.42 = mbitmap_data;
      mbitmap_data = mbitmap_data.42 + 8;
      D.19677 = *mbitmap_data.42;
      D.19678 = (unsigned int) D.19677;
      D.19679 = D.19678 + 4294967295;
      mbwords = (int) D.19679;
      D.19680 = vt->klass;
      el_size = mono_array_element_size (D.19680);
      e_start = start + 32;
      D.19602 = MEM[(struct MonoArray *)start].max_length;
      el_size.43 = (unsigned int) el_size;
      D.19682 = D.19602 * el_size.43;
      D.19683 = (sizetype) D.19682;
      e_end = e_start + D.19683;
      if (0 != 0) goto <D.19684>; else goto <D.19685>;
      <D.19684>:
      D.19675 = vt->desc;
      D.19680 = vt->klass;
      D.19686 = D.19680->name_space;
      D.19680 = vt->klass;
      D.19687 = D.19680->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19675, D.19686, D.19687);
      <D.19685>:
      goto <D.18991>;
      <D.18990>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.18988>;
        <D.18987>:
        {
          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.18985>;
          <D.18984>:
          D.19689 = _bmap & 1;
          if (D.19689 != 0) goto <D.19690>; else goto <D.19691>;
          <D.19690>:
          {
            void * __old;

            __old = *_objptr;
            if (__old != 0B) goto <D.19692>; else goto <D.19693>;
            <D.19692>:
            split_nursery_serial_copy_object_from_obj (_objptr, queue);
            if (0 != 0) goto <D.19694>; else goto <D.19695>;
            <D.19694>:
            D.19696 = *_objptr;
            if (D.19696 != __old) goto <D.19697>; else goto <D.19698>;
            <D.19697>:
            gc_debug_file.38 = gc_debug_file;
            D.19696 = *_objptr;
            fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19696, __old);
            gc_debug_file.38 = gc_debug_file;
            fflush (gc_debug_file.38);
            <D.19698>:
            <D.19695>:
            <D.19693>:
          }
          <D.19691>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18985>:
          if (_bmap != 0) goto <D.18984>; else goto <D.18986>;
          <D.18986>:
          _objptr = start_run + 512;
        }
        <D.18988>:
        bwords.45 = bwords;
        bwords = bwords.45 + 4294967295;
        if (bwords.45 != 0) goto <D.18987>; else goto <D.18989>;
        <D.18989>:
        D.19700 = (sizetype) el_size;
        e_start = e_start + D.19700;
      }
      <D.18991>:
      if (e_start < e_end) goto <D.18990>; else goto <D.18992>;
      <D.18992>:
    }
    goto <D.18907>;
    <D.18993>:
    goto <D.18907>;
    <D.18994>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.18907>:
  }
}


split_nursery_parallel_scan_vtype (char * start, mword desc, struct SgenGrayQueue * queue)
{
  long unsigned int D.19702;
  long unsigned int D.19703;
  long unsigned int D.19706;
  long unsigned int D.19707;
  long unsigned int D.19708;
  long unsigned int D.19709;
  long unsigned int D.19710;
  long unsigned int D.19711;
  struct FILE * gc_debug_file.46;
  void * D.19719;
  int iftmp.47;
  int D.19723;
  int D.19725;
  _Bool D.19727;
  long int D.19728;
  long int D.19729;
  int iftmp.48;
  int D.19741;
  int D.19743;
  _Bool D.19745;
  long int D.19746;
  long int D.19747;
  long unsigned int D.19750;
  long unsigned int D.19751;
  int D.19752;
  void * D.19759;
  int iftmp.49;
  int D.19763;
  int D.19765;
  _Bool D.19767;
  long int D.19768;
  long int D.19769;
  long unsigned int D.19772;
  long unsigned int D.19773;
  int D.19774;
  int iftmp.50;
  int D.19784;
  int D.19786;
  _Bool D.19788;
  long int D.19789;
  long int D.19790;
  long unsigned int D.19793;
  long unsigned int D.19796;
  int D.19797;
  int D.19798;
  unsigned int D.19801;
  unsigned int el_size.51;
  unsigned int D.19803;
  sizetype D.19804;
  void * D.19811;
  int iftmp.52;
  int D.19815;
  int D.19817;
  _Bool D.19819;
  long int D.19820;
  long int D.19821;
  int D.19827;
  int D.19828;
  long unsigned int D.19829;
  long unsigned int D.19830;
  long unsigned int D.19831;
  long unsigned int D.19832;
  void * * D.19833;
  void * D.19840;
  int iftmp.53;
  int D.19844;
  void * D.19846;
  int D.19847;
  _Bool D.19849;
  long int D.19850;
  long int D.19851;
  void * D.19854;
  sizetype D.19855;
  long unsigned int D.19859;
  void * D.19868;
  int iftmp.54;
  int D.19872;
  int D.19874;
  _Bool D.19876;
  long int D.19877;
  long int D.19878;
  long unsigned int D.19881;
  void * D.19890;
  int iftmp.55;
  int D.19894;
  int D.19896;
  _Bool D.19898;
  long int D.19899;
  long int D.19900;
  long unsigned int D.19903;
  unsigned int D.19904;
  unsigned int D.19905;
  struct MonoVTable * D.19908;
  struct MonoClass * D.19909;
  const char * D.19910;
  const char * D.19911;
  gsize * bitmap_data.56;
  long unsigned int D.19913;
  void * D.19922;
  int iftmp.57;
  int D.19926;
  int D.19928;
  _Bool D.19930;
  long int D.19931;
  long int D.19932;
  int bwords.58;

  start = start + 18446744073709551600;
  D.19702 = desc & 7;
  switch (D.19702) <default: <D.18892>, case 1: <D.18809>, case 2: <D.18820>, case 3: <D.18876>, case 4: <D.18832>, case 5: <D.18868>, case 7: <D.18891>>
  <D.18809>:
  D.19703 = desc & 4294901760;
  if (D.19703 != 0) goto <D.19704>; else goto <D.19705>;
  <D.19704>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.19706 = desc >> 16;
    D.19707 = D.19706 & 255;
    D.19708 = D.19707 * 8;
    _objptr = _objptr + D.19708;
    D.19709 = desc >> 24;
    D.19710 = D.19709 & 255;
    D.19711 = D.19710 * 8;
    _objptr_end = _objptr + D.19711;
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.19712>; else goto <D.19713>;
      <D.19712>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.19714>; else goto <D.19715>;
      <D.19714>:
      if (__old != __copy) goto <D.19716>; else goto <D.19717>;
      <D.19716>:
      gc_debug_file.46 = gc_debug_file;
      D.19719 = *_objptr;
      fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19719, __old);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19717>:
      <D.19715>:
      D.19723 = sgen_ptr_in_nursery (__copy);
      if (D.19723 != 0) goto <D.19724>; else goto <D.19721>;
      <D.19724>:
      D.19725 = sgen_ptr_in_nursery (_objptr);
      if (D.19725 == 0) goto <D.19726>; else goto <D.19721>;
      <D.19726>:
      iftmp.47 = 1;
      goto <D.19722>;
      <D.19721>:
      iftmp.47 = 0;
      <D.19722>:
      D.19727 = iftmp.47 != 0;
      D.19728 = (long int) D.19727;
      D.19729 = __builtin_expect (D.19728, 0);
      if (D.19729 != 0) goto <D.19730>; else goto <D.19731>;
      <D.19730>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.19731>:
      <D.19713>:
    }
    _objptr = _objptr + 8;
    goto <D.18817>;
    <D.18816>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.19732>; else goto <D.19733>;
      <D.19732>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.19734>; else goto <D.19735>;
      <D.19734>:
      if (__old != __copy) goto <D.19736>; else goto <D.19737>;
      <D.19736>:
      gc_debug_file.46 = gc_debug_file;
      D.19719 = *_objptr;
      fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19719, __old);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19737>:
      <D.19735>:
      D.19741 = sgen_ptr_in_nursery (__copy);
      if (D.19741 != 0) goto <D.19742>; else goto <D.19739>;
      <D.19742>:
      D.19743 = sgen_ptr_in_nursery (_objptr);
      if (D.19743 == 0) goto <D.19744>; else goto <D.19739>;
      <D.19744>:
      iftmp.48 = 1;
      goto <D.19740>;
      <D.19739>:
      iftmp.48 = 0;
      <D.19740>:
      D.19745 = iftmp.48 != 0;
      D.19746 = (long int) D.19745;
      D.19747 = __builtin_expect (D.19746, 0);
      if (D.19747 != 0) goto <D.19748>; else goto <D.19749>;
      <D.19748>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.19749>:
      <D.19733>:
    }
    _objptr = _objptr + 8;
    <D.18817>:
    if (_objptr < _objptr_end) goto <D.18816>; else goto <D.18818>;
    <D.18818>:
  }
  <D.19705>:
  goto <D.18819>;
  <D.18820>:
  {
    void * * _objptr;
    gsize _bmap;

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

      _index = __builtin_ctzl (_bmap);
      D.19750 = (long unsigned int) _index;
      D.19751 = D.19750 * 8;
      _objptr = _objptr + D.19751;
      D.19752 = _index + 1;
      _bmap = _bmap >> D.19752;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19753>; else goto <D.19754>;
        <D.19753>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19755>; else goto <D.19756>;
        <D.19755>:
        if (__old != __copy) goto <D.19757>; else goto <D.19758>;
        <D.19757>:
        gc_debug_file.46 = gc_debug_file;
        D.19759 = *_objptr;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19759, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19758>:
        <D.19756>:
        D.19763 = sgen_ptr_in_nursery (__copy);
        if (D.19763 != 0) goto <D.19764>; else goto <D.19761>;
        <D.19764>:
        D.19765 = sgen_ptr_in_nursery (_objptr);
        if (D.19765 == 0) goto <D.19766>; else goto <D.19761>;
        <D.19766>:
        iftmp.49 = 1;
        goto <D.19762>;
        <D.19761>:
        iftmp.49 = 0;
        <D.19762>:
        D.19767 = iftmp.49 != 0;
        D.19768 = (long int) D.19767;
        D.19769 = __builtin_expect (D.19768, 0);
        if (D.19769 != 0) goto <D.19770>; else goto <D.19771>;
        <D.19770>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19771>:
        <D.19754>:
      }
      _objptr = _objptr + 8;
    }
    goto <D.18830>;
    <D.18829>:
    {
      int _index;

      _index = __builtin_ctzl (_bmap);
      D.19772 = (long unsigned int) _index;
      D.19773 = D.19772 * 8;
      _objptr = _objptr + D.19773;
      D.19774 = _index + 1;
      _bmap = _bmap >> D.19774;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19775>; else goto <D.19776>;
        <D.19775>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19777>; else goto <D.19778>;
        <D.19777>:
        if (__old != __copy) goto <D.19779>; else goto <D.19780>;
        <D.19779>:
        gc_debug_file.46 = gc_debug_file;
        D.19759 = *_objptr;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19759, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19780>:
        <D.19778>:
        D.19784 = sgen_ptr_in_nursery (__copy);
        if (D.19784 != 0) goto <D.19785>; else goto <D.19782>;
        <D.19785>:
        D.19786 = sgen_ptr_in_nursery (_objptr);
        if (D.19786 == 0) goto <D.19787>; else goto <D.19782>;
        <D.19787>:
        iftmp.50 = 1;
        goto <D.19783>;
        <D.19782>:
        iftmp.50 = 0;
        <D.19783>:
        D.19788 = iftmp.50 != 0;
        D.19789 = (long int) D.19788;
        D.19790 = __builtin_expect (D.19789, 0);
        if (D.19790 != 0) goto <D.19791>; else goto <D.19792>;
        <D.19791>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19792>:
        <D.19776>:
      }
      _objptr = _objptr + 8;
    }
    <D.18830>:
    if (_bmap != 0) goto <D.18829>; else goto <D.18831>;
    <D.18831>:
  }
  goto <D.18819>;
  <D.18832>:
  D.19793 = desc & 4294950912;
  if (D.19793 != 0) goto <D.19794>; else goto <D.19795>;
  <D.19794>:
  {
    int el_size;
    int etype;

    D.19796 = desc >> 3;
    D.19797 = (int) D.19796;
    el_size = D.19797 & 1023;
    D.19798 = (int) desc;
    etype = D.19798 & 49152;
    if (etype == 16384) goto <D.19799>; else goto <D.19800>;
    <D.19799>:
    {
      void * * p;
      void * * end_refs;

      p = start + 32;
      D.19801 = MEM[(struct MonoArray *)start].max_length;
      el_size.51 = (unsigned int) el_size;
      D.19803 = D.19801 * el_size.51;
      D.19804 = (sizetype) D.19803;
      end_refs = p + D.19804;
      goto <D.18840>;
      <D.18839>:
      {
        void * __old;
        void * __copy;

        __old = *p;
        if (__old != 0B) goto <D.19805>; else goto <D.19806>;
        <D.19805>:
        split_nursery_parallel_copy_object (p, queue);
        __copy = *p;
        if (0 != 0) goto <D.19807>; else goto <D.19808>;
        <D.19807>:
        if (__old != __copy) goto <D.19809>; else goto <D.19810>;
        <D.19809>:
        gc_debug_file.46 = gc_debug_file;
        D.19811 = *p;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", p, D.19811, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19810>:
        <D.19808>:
        D.19815 = sgen_ptr_in_nursery (__copy);
        if (D.19815 != 0) goto <D.19816>; else goto <D.19813>;
        <D.19816>:
        D.19817 = sgen_ptr_in_nursery (p);
        if (D.19817 == 0) goto <D.19818>; else goto <D.19813>;
        <D.19818>:
        iftmp.52 = 1;
        goto <D.19814>;
        <D.19813>:
        iftmp.52 = 0;
        <D.19814>:
        D.19819 = iftmp.52 != 0;
        D.19820 = (long int) D.19819;
        D.19821 = __builtin_expect (D.19820, 0);
        if (D.19821 != 0) goto <D.19822>; else goto <D.19823>;
        <D.19822>:
        sgen_add_to_global_remset (p, __copy);
        <D.19823>:
        <D.19806>:
      }
      p = p + 8;
      <D.18840>:
      if (p < end_refs) goto <D.18839>; else goto <D.18841>;
      <D.18841>:
    }
    goto <D.19824>;
    <D.19800>:
    if (etype == 32768) goto <D.19825>; else goto <D.19826>;
    <D.19825>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.19706 = desc >> 16;
      D.19827 = (int) D.19706;
      offset = D.19827 & 255;
      D.19709 = desc >> 24;
      D.19828 = (int) D.19709;
      num_refs = D.19828 & 255;
      e_start = start + 32;
      D.19801 = MEM[(struct MonoArray *)start].max_length;
      el_size.51 = (unsigned int) el_size;
      D.19803 = D.19801 * el_size.51;
      D.19804 = (sizetype) D.19803;
      e_end = e_start + D.19804;
      goto <D.18854>;
      <D.18853>:
      {
        void * * p;
        int i;

        p = e_start;
        D.19829 = (long unsigned int) offset;
        D.19830 = D.19829 * 8;
        p = p + D.19830;
        i = 0;
        goto <D.18851>;
        <D.18850>:
        {
          void * __old;
          void * __copy;

          D.19831 = (long unsigned int) i;
          D.19832 = D.19831 * 8;
          D.19833 = p + D.19832;
          __old = *D.19833;
          if (__old != 0B) goto <D.19834>; else goto <D.19835>;
          <D.19834>:
          D.19831 = (long unsigned int) i;
          D.19832 = D.19831 * 8;
          D.19833 = p + D.19832;
          split_nursery_parallel_copy_object (D.19833, queue);
          D.19831 = (long unsigned int) i;
          D.19832 = D.19831 * 8;
          D.19833 = p + D.19832;
          __copy = *D.19833;
          if (0 != 0) goto <D.19836>; else goto <D.19837>;
          <D.19836>:
          if (__old != __copy) goto <D.19838>; else goto <D.19839>;
          <D.19838>:
          gc_debug_file.46 = gc_debug_file;
          D.19831 = (long unsigned int) i;
          D.19832 = D.19831 * 8;
          D.19833 = p + D.19832;
          D.19831 = (long unsigned int) i;
          D.19832 = D.19831 * 8;
          D.19833 = p + D.19832;
          D.19840 = *D.19833;
          fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", D.19833, D.19840, __old);
          gc_debug_file.46 = gc_debug_file;
          fflush (gc_debug_file.46);
          <D.19839>:
          <D.19837>:
          D.19844 = sgen_ptr_in_nursery (__copy);
          if (D.19844 != 0) goto <D.19845>; else goto <D.19842>;
          <D.19845>:
          D.19831 = (long unsigned int) i;
          D.19832 = D.19831 * 8;
          D.19846 = p + D.19832;
          D.19847 = sgen_ptr_in_nursery (D.19846);
          if (D.19847 == 0) goto <D.19848>; else goto <D.19842>;
          <D.19848>:
          iftmp.53 = 1;
          goto <D.19843>;
          <D.19842>:
          iftmp.53 = 0;
          <D.19843>:
          D.19849 = iftmp.53 != 0;
          D.19850 = (long int) D.19849;
          D.19851 = __builtin_expect (D.19850, 0);
          if (D.19851 != 0) goto <D.19852>; else goto <D.19853>;
          <D.19852>:
          D.19831 = (long unsigned int) i;
          D.19832 = D.19831 * 8;
          D.19854 = p + D.19832;
          sgen_add_to_global_remset (D.19854, __copy);
          <D.19853>:
          <D.19835>:
        }
        i = i + 1;
        <D.18851>:
        if (i < num_refs) goto <D.18850>; else goto <D.18852>;
        <D.18852>:
        D.19855 = (sizetype) el_size;
        e_start = e_start + D.19855;
      }
      <D.18854>:
      if (e_start < e_end) goto <D.18853>; else goto <D.18855>;
      <D.18855>:
    }
    goto <D.19856>;
    <D.19826>:
    if (etype == 49152) goto <D.19857>; else goto <D.19858>;
    <D.19857>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 32;
      D.19801 = MEM[(struct MonoArray *)start].max_length;
      el_size.51 = (unsigned int) el_size;
      D.19803 = D.19801 * el_size.51;
      D.19804 = (sizetype) D.19803;
      e_end = e_start + D.19804;
      goto <D.18866>;
      <D.18865>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.18863>;
        <D.18862>:
        D.19859 = _bmap & 1;
        if (D.19859 != 0) goto <D.19860>; else goto <D.19861>;
        <D.19860>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.19862>; else goto <D.19863>;
          <D.19862>:
          split_nursery_parallel_copy_object (p, queue);
          __copy = *p;
          if (0 != 0) goto <D.19864>; else goto <D.19865>;
          <D.19864>:
          if (__old != __copy) goto <D.19866>; else goto <D.19867>;
          <D.19866>:
          gc_debug_file.46 = gc_debug_file;
          D.19868 = *p;
          fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", p, D.19868, __old);
          gc_debug_file.46 = gc_debug_file;
          fflush (gc_debug_file.46);
          <D.19867>:
          <D.19865>:
          D.19872 = sgen_ptr_in_nursery (__copy);
          if (D.19872 != 0) goto <D.19873>; else goto <D.19870>;
          <D.19873>:
          D.19874 = sgen_ptr_in_nursery (p);
          if (D.19874 == 0) goto <D.19875>; else goto <D.19870>;
          <D.19875>:
          iftmp.54 = 1;
          goto <D.19871>;
          <D.19870>:
          iftmp.54 = 0;
          <D.19871>:
          D.19876 = iftmp.54 != 0;
          D.19877 = (long int) D.19876;
          D.19878 = __builtin_expect (D.19877, 0);
          if (D.19878 != 0) goto <D.19879>; else goto <D.19880>;
          <D.19879>:
          sgen_add_to_global_remset (p, __copy);
          <D.19880>:
          <D.19863>:
        }
        <D.19861>:
        _bmap = _bmap >> 1;
        p = p + 8;
        <D.18863>:
        if (_bmap != 0) goto <D.18862>; else goto <D.18864>;
        <D.18864>:
        D.19855 = (sizetype) el_size;
        e_start = e_start + D.19855;
      }
      <D.18866>:
      if (e_start < e_end) goto <D.18865>; else goto <D.18867>;
      <D.18867>:
    }
    <D.19858>:
    <D.19856>:
    <D.19824>:
  }
  <D.19795>:
  goto <D.18819>;
  <D.18868>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 3;
    _objptr = _objptr + 16;
    goto <D.18874>;
    <D.18873>:
    D.19881 = _bmap & 1;
    if (D.19881 != 0) goto <D.19882>; else goto <D.19883>;
    <D.19882>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.19884>; else goto <D.19885>;
      <D.19884>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.19886>; else goto <D.19887>;
      <D.19886>:
      if (__old != __copy) goto <D.19888>; else goto <D.19889>;
      <D.19888>:
      gc_debug_file.46 = gc_debug_file;
      D.19890 = *_objptr;
      fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19890, __old);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19889>:
      <D.19887>:
      D.19894 = sgen_ptr_in_nursery (__copy);
      if (D.19894 != 0) goto <D.19895>; else goto <D.19892>;
      <D.19895>:
      D.19896 = sgen_ptr_in_nursery (_objptr);
      if (D.19896 == 0) goto <D.19897>; else goto <D.19892>;
      <D.19897>:
      iftmp.55 = 1;
      goto <D.19893>;
      <D.19892>:
      iftmp.55 = 0;
      <D.19893>:
      D.19898 = iftmp.55 != 0;
      D.19899 = (long int) D.19898;
      D.19900 = __builtin_expect (D.19899, 0);
      if (D.19900 != 0) goto <D.19901>; else goto <D.19902>;
      <D.19901>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.19902>:
      <D.19885>:
    }
    <D.19883>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 8;
    <D.18874>:
    if (_bmap != 0) goto <D.18873>; else goto <D.18875>;
    <D.18875>:
  }
  goto <D.18819>;
  <D.18876>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.19903 = *bitmap_data;
    D.19904 = (unsigned int) D.19903;
    D.19905 = D.19904 + 4294967295;
    bwords = (int) D.19905;
    start_run = _objptr;
    bitmap_data = bitmap_data + 8;
    if (0 != 0) goto <D.19906>; else goto <D.19907>;
    <D.19906>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.19908 = myobj->vtable;
      D.19909 = D.19908->klass;
      D.19910 = D.19909->name_space;
      D.19908 = myobj->vtable;
      D.19909 = D.19908->klass;
      D.19911 = D.19909->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19910, D.19911);
    }
    <D.19907>:
    goto <D.18889>;
    <D.18888>:
    {
      gsize _bmap;

      bitmap_data.56 = bitmap_data;
      bitmap_data = bitmap_data.56 + 8;
      _bmap = *bitmap_data.56;
      _objptr = start_run;
      goto <D.18886>;
      <D.18885>:
      D.19913 = _bmap & 1;
      if (D.19913 != 0) goto <D.19914>; else goto <D.19915>;
      <D.19914>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19916>; else goto <D.19917>;
        <D.19916>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19918>; else goto <D.19919>;
        <D.19918>:
        if (__old != __copy) goto <D.19920>; else goto <D.19921>;
        <D.19920>:
        gc_debug_file.46 = gc_debug_file;
        D.19922 = *_objptr;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19922, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19921>:
        <D.19919>:
        D.19926 = sgen_ptr_in_nursery (__copy);
        if (D.19926 != 0) goto <D.19927>; else goto <D.19924>;
        <D.19927>:
        D.19928 = sgen_ptr_in_nursery (_objptr);
        if (D.19928 == 0) goto <D.19929>; else goto <D.19924>;
        <D.19929>:
        iftmp.57 = 1;
        goto <D.19925>;
        <D.19924>:
        iftmp.57 = 0;
        <D.19925>:
        D.19930 = iftmp.57 != 0;
        D.19931 = (long int) D.19930;
        D.19932 = __builtin_expect (D.19931, 0);
        if (D.19932 != 0) goto <D.19933>; else goto <D.19934>;
        <D.19933>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19934>:
        <D.19917>:
      }
      <D.19915>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18886>:
      if (_bmap != 0) goto <D.18885>; else goto <D.18887>;
      <D.18887>:
      start_run = start_run + 512;
    }
    <D.18889>:
    bwords.58 = bwords;
    bwords = bwords.58 + -1;
    if (bwords.58 > 0) goto <D.18888>; else goto <D.18890>;
    <D.18890>:
  }
  goto <D.18819>;
  <D.18891>:
  goto <D.18819>;
  <D.18892>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.18819>:
}


split_nursery_parallel_scan_object (char * start, struct SgenGrayQueue * queue)
{
  long unsigned int D.19937;
  long unsigned int D.19938;
  long unsigned int D.19939;
  long unsigned int D.19940;
  long unsigned int D.19943;
  long unsigned int D.19944;
  long unsigned int D.19945;
  long unsigned int D.19946;
  long unsigned int D.19947;
  long unsigned int D.19948;
  struct FILE * gc_debug_file.59;
  void * D.19956;
  int iftmp.60;
  int D.19960;
  int D.19962;
  _Bool D.19964;
  long int D.19965;
  long int D.19966;
  int iftmp.61;
  int D.19978;
  int D.19980;
  _Bool D.19982;
  long int D.19983;
  long int D.19984;
  long unsigned int D.19987;
  long unsigned int D.19988;
  int D.19989;
  void * D.19996;
  int iftmp.62;
  int D.20000;
  int D.20002;
  _Bool D.20004;
  long int D.20005;
  long int D.20006;
  long unsigned int D.20009;
  long unsigned int D.20010;
  int D.20011;
  int iftmp.63;
  int D.20021;
  int D.20023;
  _Bool D.20025;
  long int D.20026;
  long int D.20027;
  long unsigned int D.20030;
  long unsigned int D.20033;
  int D.20034;
  int D.20035;
  unsigned int D.20038;
  unsigned int el_size.64;
  unsigned int D.20040;
  sizetype D.20041;
  void * D.20048;
  int iftmp.65;
  int D.20052;
  int D.20054;
  _Bool D.20056;
  long int D.20057;
  long int D.20058;
  int D.20064;
  int D.20065;
  long unsigned int D.20066;
  long unsigned int D.20067;
  long unsigned int D.20068;
  long unsigned int D.20069;
  void * * D.20070;
  void * D.20077;
  int iftmp.66;
  int D.20081;
  void * D.20083;
  int D.20084;
  _Bool D.20086;
  long int D.20087;
  long int D.20088;
  void * D.20091;
  sizetype D.20092;
  long unsigned int D.20096;
  void * D.20105;
  int iftmp.67;
  int D.20109;
  int D.20111;
  _Bool D.20113;
  long int D.20114;
  long int D.20115;
  long unsigned int D.20118;
  void * D.20127;
  int iftmp.68;
  int D.20131;
  int D.20133;
  _Bool D.20135;
  long int D.20136;
  long int D.20137;
  long unsigned int D.20140;
  unsigned int D.20141;
  unsigned int D.20142;
  struct MonoVTable * D.20145;
  struct MonoClass * D.20146;
  const char * D.20147;
  const char * D.20148;
  gsize * bitmap_data.69;
  long unsigned int D.20150;
  void * D.20159;
  int iftmp.70;
  int D.20163;
  int D.20165;
  _Bool D.20167;
  long int D.20168;
  long int D.20169;
  int bwords.71;
  long unsigned int D.20173;
  gsize * mbitmap_data.72;
  long unsigned int D.20175;
  unsigned int D.20176;
  unsigned int D.20177;
  struct MonoClass * D.20178;
  unsigned int el_size.73;
  unsigned int D.20180;
  sizetype D.20181;
  const char * D.20184;
  const char * D.20185;
  gsize * bitmap_data.74;
  long unsigned int D.20187;
  void * D.20196;
  int iftmp.75;
  int D.20200;
  int D.20202;
  _Bool D.20204;
  long int D.20205;
  long int D.20206;
  unsigned int bwords.76;
  sizetype D.20210;

  {
    struct GCVTable * vt;
    mword desc;

    D.19937 = MEM[(mword *)start];
    D.19938 = D.19937 & 18446744073709551612;
    vt = (struct GCVTable *) D.19938;
    desc = vt->desc;
    D.19939 = desc & 7;
    switch (D.19939) <default: <D.18803>, case 1: <D.18698>, case 2: <D.18709>, case 3: <D.18765>, case 4: <D.18721>, case 5: <D.18757>, case 6: <D.18780>, case 7: <D.18802>>
    <D.18698>:
    D.19940 = desc & 4294901760;
    if (D.19940 != 0) goto <D.19941>; else goto <D.19942>;
    <D.19941>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19943 = desc >> 16;
      D.19944 = D.19943 & 255;
      D.19945 = D.19944 * 8;
      _objptr = _objptr + D.19945;
      D.19946 = desc >> 24;
      D.19947 = D.19946 & 255;
      D.19948 = D.19947 * 8;
      _objptr_end = _objptr + D.19948;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19949>; else goto <D.19950>;
        <D.19949>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19951>; else goto <D.19952>;
        <D.19951>:
        if (__old != __copy) goto <D.19953>; else goto <D.19954>;
        <D.19953>:
        gc_debug_file.59 = gc_debug_file;
        D.19956 = *_objptr;
        fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19956, __old);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.19954>:
        <D.19952>:
        D.19960 = sgen_ptr_in_nursery (__copy);
        if (D.19960 != 0) goto <D.19961>; else goto <D.19958>;
        <D.19961>:
        D.19962 = sgen_ptr_in_nursery (_objptr);
        if (D.19962 == 0) goto <D.19963>; else goto <D.19958>;
        <D.19963>:
        iftmp.60 = 1;
        goto <D.19959>;
        <D.19958>:
        iftmp.60 = 0;
        <D.19959>:
        D.19964 = iftmp.60 != 0;
        D.19965 = (long int) D.19964;
        D.19966 = __builtin_expect (D.19965, 0);
        if (D.19966 != 0) goto <D.19967>; else goto <D.19968>;
        <D.19967>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19968>:
        <D.19950>:
      }
      _objptr = _objptr + 8;
      goto <D.18706>;
      <D.18705>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19969>; else goto <D.19970>;
        <D.19969>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19971>; else goto <D.19972>;
        <D.19971>:
        if (__old != __copy) goto <D.19973>; else goto <D.19974>;
        <D.19973>:
        gc_debug_file.59 = gc_debug_file;
        D.19956 = *_objptr;
        fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19956, __old);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.19974>:
        <D.19972>:
        D.19978 = sgen_ptr_in_nursery (__copy);
        if (D.19978 != 0) goto <D.19979>; else goto <D.19976>;
        <D.19979>:
        D.19980 = sgen_ptr_in_nursery (_objptr);
        if (D.19980 == 0) goto <D.19981>; else goto <D.19976>;
        <D.19981>:
        iftmp.61 = 1;
        goto <D.19977>;
        <D.19976>:
        iftmp.61 = 0;
        <D.19977>:
        D.19982 = iftmp.61 != 0;
        D.19983 = (long int) D.19982;
        D.19984 = __builtin_expect (D.19983, 0);
        if (D.19984 != 0) goto <D.19985>; else goto <D.19986>;
        <D.19985>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19986>:
        <D.19970>:
      }
      _objptr = _objptr + 8;
      <D.18706>:
      if (_objptr < _objptr_end) goto <D.18705>; else goto <D.18707>;
      <D.18707>:
    }
    <D.19942>:
    goto <D.18708>;
    <D.18709>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.19987 = (long unsigned int) _index;
        D.19988 = D.19987 * 8;
        _objptr = _objptr + D.19988;
        D.19989 = _index + 1;
        _bmap = _bmap >> D.19989;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.19990>; else goto <D.19991>;
          <D.19990>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.19992>; else goto <D.19993>;
          <D.19992>:
          if (__old != __copy) goto <D.19994>; else goto <D.19995>;
          <D.19994>:
          gc_debug_file.59 = gc_debug_file;
          D.19996 = *_objptr;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19996, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.19995>:
          <D.19993>:
          D.20000 = sgen_ptr_in_nursery (__copy);
          if (D.20000 != 0) goto <D.20001>; else goto <D.19998>;
          <D.20001>:
          D.20002 = sgen_ptr_in_nursery (_objptr);
          if (D.20002 == 0) goto <D.20003>; else goto <D.19998>;
          <D.20003>:
          iftmp.62 = 1;
          goto <D.19999>;
          <D.19998>:
          iftmp.62 = 0;
          <D.19999>:
          D.20004 = iftmp.62 != 0;
          D.20005 = (long int) D.20004;
          D.20006 = __builtin_expect (D.20005, 0);
          if (D.20006 != 0) goto <D.20007>; else goto <D.20008>;
          <D.20007>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.20008>:
          <D.19991>:
        }
        _objptr = _objptr + 8;
      }
      goto <D.18719>;
      <D.18718>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.20009 = (long unsigned int) _index;
        D.20010 = D.20009 * 8;
        _objptr = _objptr + D.20010;
        D.20011 = _index + 1;
        _bmap = _bmap >> D.20011;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.20012>; else goto <D.20013>;
          <D.20012>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.20014>; else goto <D.20015>;
          <D.20014>:
          if (__old != __copy) goto <D.20016>; else goto <D.20017>;
          <D.20016>:
          gc_debug_file.59 = gc_debug_file;
          D.19996 = *_objptr;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19996, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.20017>:
          <D.20015>:
          D.20021 = sgen_ptr_in_nursery (__copy);
          if (D.20021 != 0) goto <D.20022>; else goto <D.20019>;
          <D.20022>:
          D.20023 = sgen_ptr_in_nursery (_objptr);
          if (D.20023 == 0) goto <D.20024>; else goto <D.20019>;
          <D.20024>:
          iftmp.63 = 1;
          goto <D.20020>;
          <D.20019>:
          iftmp.63 = 0;
          <D.20020>:
          D.20025 = iftmp.63 != 0;
          D.20026 = (long int) D.20025;
          D.20027 = __builtin_expect (D.20026, 0);
          if (D.20027 != 0) goto <D.20028>; else goto <D.20029>;
          <D.20028>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.20029>:
          <D.20013>:
        }
        _objptr = _objptr + 8;
      }
      <D.18719>:
      if (_bmap != 0) goto <D.18718>; else goto <D.18720>;
      <D.18720>:
    }
    goto <D.18708>;
    <D.18721>:
    D.20030 = desc & 4294950912;
    if (D.20030 != 0) goto <D.20031>; else goto <D.20032>;
    <D.20031>:
    {
      int el_size;
      int etype;

      D.20033 = desc >> 3;
      D.20034 = (int) D.20033;
      el_size = D.20034 & 1023;
      D.20035 = (int) desc;
      etype = D.20035 & 49152;
      if (etype == 16384) goto <D.20036>; else goto <D.20037>;
      <D.20036>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.20038 = MEM[(struct MonoArray *)start].max_length;
        el_size.64 = (unsigned int) el_size;
        D.20040 = D.20038 * el_size.64;
        D.20041 = (sizetype) D.20040;
        end_refs = p + D.20041;
        goto <D.18729>;
        <D.18728>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.20042>; else goto <D.20043>;
          <D.20042>:
          split_nursery_parallel_copy_object (p, queue);
          __copy = *p;
          if (0 != 0) goto <D.20044>; else goto <D.20045>;
          <D.20044>:
          if (__old != __copy) goto <D.20046>; else goto <D.20047>;
          <D.20046>:
          gc_debug_file.59 = gc_debug_file;
          D.20048 = *p;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", p, D.20048, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.20047>:
          <D.20045>:
          D.20052 = sgen_ptr_in_nursery (__copy);
          if (D.20052 != 0) goto <D.20053>; else goto <D.20050>;
          <D.20053>:
          D.20054 = sgen_ptr_in_nursery (p);
          if (D.20054 == 0) goto <D.20055>; else goto <D.20050>;
          <D.20055>:
          iftmp.65 = 1;
          goto <D.20051>;
          <D.20050>:
          iftmp.65 = 0;
          <D.20051>:
          D.20056 = iftmp.65 != 0;
          D.20057 = (long int) D.20056;
          D.20058 = __builtin_expect (D.20057, 0);
          if (D.20058 != 0) goto <D.20059>; else goto <D.20060>;
          <D.20059>:
          sgen_add_to_global_remset (p, __copy);
          <D.20060>:
          <D.20043>:
        }
        p = p + 8;
        <D.18729>:
        if (p < end_refs) goto <D.18728>; else goto <D.18730>;
        <D.18730>:
      }
      goto <D.20061>;
      <D.20037>:
      if (etype == 32768) goto <D.20062>; else goto <D.20063>;
      <D.20062>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19943 = desc >> 16;
        D.20064 = (int) D.19943;
        offset = D.20064 & 255;
        D.19946 = desc >> 24;
        D.20065 = (int) D.19946;
        num_refs = D.20065 & 255;
        e_start = start + 32;
        D.20038 = MEM[(struct MonoArray *)start].max_length;
        el_size.64 = (unsigned int) el_size;
        D.20040 = D.20038 * el_size.64;
        D.20041 = (sizetype) D.20040;
        e_end = e_start + D.20041;
        goto <D.18743>;
        <D.18742>:
        {
          void * * p;
          int i;

          p = e_start;
          D.20066 = (long unsigned int) offset;
          D.20067 = D.20066 * 8;
          p = p + D.20067;
          i = 0;
          goto <D.18740>;
          <D.18739>:
          {
            void * __old;
            void * __copy;

            D.20068 = (long unsigned int) i;
            D.20069 = D.20068 * 8;
            D.20070 = p + D.20069;
            __old = *D.20070;
            if (__old != 0B) goto <D.20071>; else goto <D.20072>;
            <D.20071>:
            D.20068 = (long unsigned int) i;
            D.20069 = D.20068 * 8;
            D.20070 = p + D.20069;
            split_nursery_parallel_copy_object (D.20070, queue);
            D.20068 = (long unsigned int) i;
            D.20069 = D.20068 * 8;
            D.20070 = p + D.20069;
            __copy = *D.20070;
            if (0 != 0) goto <D.20073>; else goto <D.20074>;
            <D.20073>:
            if (__old != __copy) goto <D.20075>; else goto <D.20076>;
            <D.20075>:
            gc_debug_file.59 = gc_debug_file;
            D.20068 = (long unsigned int) i;
            D.20069 = D.20068 * 8;
            D.20070 = p + D.20069;
            D.20068 = (long unsigned int) i;
            D.20069 = D.20068 * 8;
            D.20070 = p + D.20069;
            D.20077 = *D.20070;
            fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", D.20070, D.20077, __old);
            gc_debug_file.59 = gc_debug_file;
            fflush (gc_debug_file.59);
            <D.20076>:
            <D.20074>:
            D.20081 = sgen_ptr_in_nursery (__copy);
            if (D.20081 != 0) goto <D.20082>; else goto <D.20079>;
            <D.20082>:
            D.20068 = (long unsigned int) i;
            D.20069 = D.20068 * 8;
            D.20083 = p + D.20069;
            D.20084 = sgen_ptr_in_nursery (D.20083);
            if (D.20084 == 0) goto <D.20085>; else goto <D.20079>;
            <D.20085>:
            iftmp.66 = 1;
            goto <D.20080>;
            <D.20079>:
            iftmp.66 = 0;
            <D.20080>:
            D.20086 = iftmp.66 != 0;
            D.20087 = (long int) D.20086;
            D.20088 = __builtin_expect (D.20087, 0);
            if (D.20088 != 0) goto <D.20089>; else goto <D.20090>;
            <D.20089>:
            D.20068 = (long unsigned int) i;
            D.20069 = D.20068 * 8;
            D.20091 = p + D.20069;
            sgen_add_to_global_remset (D.20091, __copy);
            <D.20090>:
            <D.20072>:
          }
          i = i + 1;
          <D.18740>:
          if (i < num_refs) goto <D.18739>; else goto <D.18741>;
          <D.18741>:
          D.20092 = (sizetype) el_size;
          e_start = e_start + D.20092;
        }
        <D.18743>:
        if (e_start < e_end) goto <D.18742>; else goto <D.18744>;
        <D.18744>:
      }
      goto <D.20093>;
      <D.20063>:
      if (etype == 49152) goto <D.20094>; else goto <D.20095>;
      <D.20094>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.20038 = MEM[(struct MonoArray *)start].max_length;
        el_size.64 = (unsigned int) el_size;
        D.20040 = D.20038 * el_size.64;
        D.20041 = (sizetype) D.20040;
        e_end = e_start + D.20041;
        goto <D.18755>;
        <D.18754>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.18752>;
          <D.18751>:
          D.20096 = _bmap & 1;
          if (D.20096 != 0) goto <D.20097>; else goto <D.20098>;
          <D.20097>:
          {
            void * __old;
            void * __copy;

            __old = *p;
            if (__old != 0B) goto <D.20099>; else goto <D.20100>;
            <D.20099>:
            split_nursery_parallel_copy_object (p, queue);
            __copy = *p;
            if (0 != 0) goto <D.20101>; else goto <D.20102>;
            <D.20101>:
            if (__old != __copy) goto <D.20103>; else goto <D.20104>;
            <D.20103>:
            gc_debug_file.59 = gc_debug_file;
            D.20105 = *p;
            fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", p, D.20105, __old);
            gc_debug_file.59 = gc_debug_file;
            fflush (gc_debug_file.59);
            <D.20104>:
            <D.20102>:
            D.20109 = sgen_ptr_in_nursery (__copy);
            if (D.20109 != 0) goto <D.20110>; else goto <D.20107>;
            <D.20110>:
            D.20111 = sgen_ptr_in_nursery (p);
            if (D.20111 == 0) goto <D.20112>; else goto <D.20107>;
            <D.20112>:
            iftmp.67 = 1;
            goto <D.20108>;
            <D.20107>:
            iftmp.67 = 0;
            <D.20108>:
            D.20113 = iftmp.67 != 0;
            D.20114 = (long int) D.20113;
            D.20115 = __builtin_expect (D.20114, 0);
            if (D.20115 != 0) goto <D.20116>; else goto <D.20117>;
            <D.20116>:
            sgen_add_to_global_remset (p, __copy);
            <D.20117>:
            <D.20100>:
          }
          <D.20098>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.18752>:
          if (_bmap != 0) goto <D.18751>; else goto <D.18753>;
          <D.18753>:
          D.20092 = (sizetype) el_size;
          e_start = e_start + D.20092;
        }
        <D.18755>:
        if (e_start < e_end) goto <D.18754>; else goto <D.18756>;
        <D.18756>:
      }
      <D.20095>:
      <D.20093>:
      <D.20061>:
    }
    <D.20032>:
    goto <D.18708>;
    <D.18757>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.18763>;
      <D.18762>:
      D.20118 = _bmap & 1;
      if (D.20118 != 0) goto <D.20119>; else goto <D.20120>;
      <D.20119>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.20121>; else goto <D.20122>;
        <D.20121>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.20123>; else goto <D.20124>;
        <D.20123>:
        if (__old != __copy) goto <D.20125>; else goto <D.20126>;
        <D.20125>:
        gc_debug_file.59 = gc_debug_file;
        D.20127 = *_objptr;
        fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20127, __old);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.20126>:
        <D.20124>:
        D.20131 = sgen_ptr_in_nursery (__copy);
        if (D.20131 != 0) goto <D.20132>; else goto <D.20129>;
        <D.20132>:
        D.20133 = sgen_ptr_in_nursery (_objptr);
        if (D.20133 == 0) goto <D.20134>; else goto <D.20129>;
        <D.20134>:
        iftmp.68 = 1;
        goto <D.20130>;
        <D.20129>:
        iftmp.68 = 0;
        <D.20130>:
        D.20135 = iftmp.68 != 0;
        D.20136 = (long int) D.20135;
        D.20137 = __builtin_expect (D.20136, 0);
        if (D.20137 != 0) goto <D.20138>; else goto <D.20139>;
        <D.20138>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.20139>:
        <D.20122>:
      }
      <D.20120>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18763>:
      if (_bmap != 0) goto <D.18762>; else goto <D.18764>;
      <D.18764>:
    }
    goto <D.18708>;
    <D.18765>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.20140 = *bitmap_data;
      D.20141 = (unsigned int) D.20140;
      D.20142 = D.20141 + 4294967295;
      bwords = (int) D.20142;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.20143>; else goto <D.20144>;
      <D.20143>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.20145 = myobj->vtable;
        D.20146 = D.20145->klass;
        D.20147 = D.20146->name_space;
        D.20145 = myobj->vtable;
        D.20146 = D.20145->klass;
        D.20148 = D.20146->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.20147, D.20148);
      }
      <D.20144>:
      goto <D.18778>;
      <D.18777>:
      {
        gsize _bmap;

        bitmap_data.69 = bitmap_data;
        bitmap_data = bitmap_data.69 + 8;
        _bmap = *bitmap_data.69;
        _objptr = start_run;
        goto <D.18775>;
        <D.18774>:
        D.20150 = _bmap & 1;
        if (D.20150 != 0) goto <D.20151>; else goto <D.20152>;
        <D.20151>:
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.20153>; else goto <D.20154>;
          <D.20153>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.20155>; else goto <D.20156>;
          <D.20155>:
          if (__old != __copy) goto <D.20157>; else goto <D.20158>;
          <D.20157>:
          gc_debug_file.59 = gc_debug_file;
          D.20159 = *_objptr;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20159, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.20158>:
          <D.20156>:
          D.20163 = sgen_ptr_in_nursery (__copy);
          if (D.20163 != 0) goto <D.20164>; else goto <D.20161>;
          <D.20164>:
          D.20165 = sgen_ptr_in_nursery (_objptr);
          if (D.20165 == 0) goto <D.20166>; else goto <D.20161>;
          <D.20166>:
          iftmp.70 = 1;
          goto <D.20162>;
          <D.20161>:
          iftmp.70 = 0;
          <D.20162>:
          D.20167 = iftmp.70 != 0;
          D.20168 = (long int) D.20167;
          D.20169 = __builtin_expect (D.20168, 0);
          if (D.20169 != 0) goto <D.20170>; else goto <D.20171>;
          <D.20170>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.20171>:
          <D.20154>:
        }
        <D.20152>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18775>:
        if (_bmap != 0) goto <D.18774>; else goto <D.18776>;
        <D.18776>:
        start_run = start_run + 512;
      }
      <D.18778>:
      bwords.71 = bwords;
      bwords = bwords.71 + -1;
      if (bwords.71 > 0) goto <D.18777>; else goto <D.18779>;
      <D.18779>:
    }
    goto <D.18708>;
    <D.18780>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.20173 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.20173);
      mbitmap_data.72 = mbitmap_data;
      mbitmap_data = mbitmap_data.72 + 8;
      D.20175 = *mbitmap_data.72;
      D.20176 = (unsigned int) D.20175;
      D.20177 = D.20176 + 4294967295;
      mbwords = (int) D.20177;
      D.20178 = vt->klass;
      el_size = mono_array_element_size (D.20178);
      e_start = start + 32;
      D.20038 = MEM[(struct MonoArray *)start].max_length;
      el_size.73 = (unsigned int) el_size;
      D.20180 = D.20038 * el_size.73;
      D.20181 = (sizetype) D.20180;
      e_end = e_start + D.20181;
      if (0 != 0) goto <D.20182>; else goto <D.20183>;
      <D.20182>:
      D.20173 = vt->desc;
      D.20178 = vt->klass;
      D.20184 = D.20178->name_space;
      D.20178 = vt->klass;
      D.20185 = D.20178->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.20173, D.20184, D.20185);
      <D.20183>:
      goto <D.18800>;
      <D.18799>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.18797>;
        <D.18796>:
        {
          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.18794>;
          <D.18793>:
          D.20187 = _bmap & 1;
          if (D.20187 != 0) goto <D.20188>; else goto <D.20189>;
          <D.20188>:
          {
            void * __old;
            void * __copy;

            __old = *_objptr;
            if (__old != 0B) goto <D.20190>; else goto <D.20191>;
            <D.20190>:
            split_nursery_parallel_copy_object (_objptr, queue);
            __copy = *_objptr;
            if (0 != 0) goto <D.20192>; else goto <D.20193>;
            <D.20192>:
            if (__old != __copy) goto <D.20194>; else goto <D.20195>;
            <D.20194>:
            gc_debug_file.59 = gc_debug_file;
            D.20196 = *_objptr;
            fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20196, __old);
            gc_debug_file.59 = gc_debug_file;
            fflush (gc_debug_file.59);
            <D.20195>:
            <D.20193>:
            D.20200 = sgen_ptr_in_nursery (__copy);
            if (D.20200 != 0) goto <D.20201>; else goto <D.20198>;
            <D.20201>:
            D.20202 = sgen_ptr_in_nursery (_objptr);
            if (D.20202 == 0) goto <D.20203>; else goto <D.20198>;
            <D.20203>:
            iftmp.75 = 1;
            goto <D.20199>;
            <D.20198>:
            iftmp.75 = 0;
            <D.20199>:
            D.20204 = iftmp.75 != 0;
            D.20205 = (long int) D.20204;
            D.20206 = __builtin_expect (D.20205, 0);
            if (D.20206 != 0) goto <D.20207>; else goto <D.20208>;
            <D.20207>:
            sgen_add_to_global_remset (_objptr, __copy);
            <D.20208>:
            <D.20191>:
          }
          <D.20189>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18794>:
          if (_bmap != 0) goto <D.18793>; else goto <D.18795>;
          <D.18795>:
          _objptr = start_run + 512;
        }
        <D.18797>:
        bwords.76 = bwords;
        bwords = bwords.76 + 4294967295;
        if (bwords.76 != 0) goto <D.18796>; else goto <D.18798>;
        <D.18798>:
        D.20210 = (sizetype) el_size;
        e_start = e_start + D.20210;
      }
      <D.18800>:
      if (e_start < e_end) goto <D.18799>; else goto <D.18801>;
      <D.18801>:
    }
    goto <D.18708>;
    <D.18802>:
    goto <D.18708>;
    <D.18803>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.18708>:
  }
}


split_nursery_parallel_copy_object (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.77;
  int D.20215;
  long unsigned int D.20218;
  long unsigned int D.20219;
  long unsigned int D.20222;
  int D.20225;
  unsigned int D.20228;
  unsigned int D.20229;
  long unsigned int D.20230;
  void * D.20231;
  long unsigned int D.20232;
  _Bool D.20233;
  long int D.20234;
  long int D.20235;
  long unsigned int destination.78;
  long unsigned int D.20239;
  void * D.20240;
  void * D.20241;
  struct SgenGrayQueue * iftmp.79;
  int D.20249;
  _Bool D.20253;
  long int D.20254;
  long int D.20255;
  char * obj;
  mword vtable_word;
  mword objsize;
  struct MonoVTable * vt;
  void * destination;
  gboolean has_references;

  obj = *obj_slot;
  if (0 != 0) goto <D.20212>; else goto <D.20213>;
  <D.20212>:
  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.18690>:
  goto <D.18690>;
  <D.20213>:
  D.20215 = sgen_ptr_in_nursery (obj);
  if (D.20215 == 0) goto <D.20216>; else goto <D.20217>;
  <D.20216>:
  return;
  <D.20217>:
  vtable_word = MEM[(mword *)obj];
  D.20218 = vtable_word & 18446744073709551612;
  vt = (struct MonoVTable *) D.20218;
  D.20219 = vtable_word & 1;
  if (D.20219 != 0) goto <D.20220>; else goto <D.20221>;
  <D.20220>:
  *obj_slot = vt;
  return;
  <D.20221>:
  D.20222 = vtable_word & 2;
  if (D.20222 != 0) goto <D.20223>; else goto <D.20224>;
  <D.20223>:
  return;
  <D.20224>:
  D.20225 = sgen_nursery_is_to_space (obj);
  if (D.20225 != 0) goto <D.20226>; else goto <D.20227>;
  <D.20226>:
  return;
  <D.20227>:
  D.20228 = sgen_par_object_get_size (vt, obj);
  D.20229 = D.20228 + 7;
  D.20230 = (long unsigned int) D.20229;
  objsize = D.20230 & 4294967288;
  D.20231 = vt->gc_descr;
  D.20232 = (long unsigned int) D.20231;
  has_references = sgen_gc_descr_has_references (D.20232);
  destination = par_alloc_for_promotion (vt, obj, objsize, has_references);
  D.20233 = destination == 0B;
  D.20234 = (long int) D.20233;
  D.20235 = __builtin_expect (D.20234, 0);
  if (D.20235 != 0) goto <D.20236>; else goto <D.20237>;
  <D.20236>:
  sgen_parallel_pin_or_update (obj_slot, obj, vt, queue);
  return;
  <D.20237>:
  MEM[(struct MonoVTable * *)destination] = vt;
  destination.78 = (long unsigned int) destination;
  D.20239 = destination.78 | 1;
  D.20240 = (void *) D.20239;
  D.20241 = InterlockedCompareExchangePointer (obj, D.20240, vt);
  if (D.20241 == vt) goto <D.20242>; else goto <D.20243>;
  <D.20242>:
  if (has_references != 0) goto <D.20245>; else goto <D.20246>;
  <D.20245>:
  iftmp.79 = queue;
  goto <D.20247>;
  <D.20246>:
  iftmp.79 = 0B;
  <D.20247>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.79);
  obj = destination;
  *obj_slot = obj;
  goto <D.20248>;
  <D.20243>:
  D.20249 = sgen_ptr_in_nursery (destination);
  if (D.20249 == 0) goto <D.20250>; else goto <D.20251>;
  <D.20250>:
  MEM[(void * *)destination] = 0B;
  goto <D.20252>;
  <D.20251>:
  memset (destination, 0, objsize);
  <D.20252>:
  vtable_word = MEM[(mword *)obj];
  D.20219 = vtable_word & 1;
  D.20253 = D.20219 == 0;
  D.20254 = (long int) D.20253;
  D.20255 = __builtin_expect (D.20254, 0);
  if (D.20255 != 0) goto <D.20256>; else goto <D.20257>;
  <D.20256>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-minor-copy-object.h", 291, "vtable_word & SGEN_FORWARDED_BIT");
  <D.20257>:
  D.20218 = vtable_word & 18446744073709551612;
  obj = (char *) D.20218;
  *obj_slot = obj;
  <D.20248>:
}


par_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int promote_age.80;
  char * D.20262;
  void * (*<T2f12>) (struct MonoVTable *, int, gboolean) D.20263;
  int D.20264;
  char * D.20265;
  char * D.20266;
  _Bool D.20267;
  long int D.20268;
  long int D.20269;
  char * * D.20272;
  void * D.20273;
  void * D.20274;
  char * p;
  int age;
  void restart = <<< error >>>;

  age = get_object_age (obj);
  promote_age.80 = promote_age;
  if (age >= promote_age.80) goto <D.20260>; else goto <D.20261>;
  <D.20260>:
  D.20263 = major_collector.par_alloc_object;
  D.20264 = (int) objsize;
  D.20262 = D.20263 (vtable, D.20264, has_references);
  return D.20262;
  <D.20261>:
  restart:
  p = age_alloc_buffers[age].next;
  mono_memory_read_barrier ();
  D.20265 = p + objsize;
  D.20266 = age_alloc_buffers[age].end;
  D.20267 = D.20265 <= D.20266;
  D.20268 = (long int) D.20267;
  D.20269 = __builtin_expect (D.20268, 1);
  if (D.20269 != 0) goto <D.20270>; else goto <D.20271>;
  <D.20270>:
  D.20272 = &age_alloc_buffers[age].next;
  D.20273 = p + objsize;
  D.20274 = InterlockedCompareExchangePointer (D.20272, D.20273, p);
  if (D.20274 != p) goto restart; else goto <D.20275>;
  <D.20275>:
  goto <D.20276>;
  <D.20271>:
  p = par_alloc_for_promotion_slow_path (age, objsize);
  if (p == 0B) goto <D.20277>; else goto <D.20278>;
  <D.20277>:
  D.20263 = major_collector.par_alloc_object;
  D.20264 = (int) objsize;
  D.20262 = D.20263 (vtable, D.20264, has_references);
  return D.20262;
  <D.20278>:
  <D.20276>:
  MEM[(struct MonoVTable * *)p] = vtable;
  D.20262 = p;
  return D.20262;
}


mono_memory_read_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


par_alloc_for_promotion_slow_path (int age, size_t objsize)
{
  long unsigned int D.20280;
  char * D.20281;
  char * D.20282;
  _Bool D.20283;
  long int D.20284;
  long int D.20285;
  char * * D.20288;
  void * D.20289;
  void * D.20290;
  void * D.20295;
  long unsigned int D.20296;
  long unsigned int D.20297;
  long unsigned int allocated_size.81;
  char * D.20301;
  char * D.20302;
  char * p;
  size_t allocated_size;
  size_t aligned_objsize;
  void restart = <<< error >>>;

  try
    {
      D.20280 = objsize + 511;
      aligned_objsize = D.20280 & 18446744073709551104;
      pthread_mutex_lock (&par_alloc_buffer_refill_mutex);
      restart:
      p = age_alloc_buffers[age].next;
      D.20281 = p + objsize;
      D.20282 = age_alloc_buffers[age].end;
      D.20283 = D.20281 <= D.20282;
      D.20284 = (long int) D.20283;
      D.20285 = __builtin_expect (D.20284, 1);
      if (D.20285 != 0) goto <D.20286>; else goto <D.20287>;
      <D.20286>:
      D.20288 = &age_alloc_buffers[age].next;
      D.20289 = p + objsize;
      D.20290 = InterlockedCompareExchangePointer (D.20288, D.20289, p);
      if (D.20290 != p) goto restart; else goto <D.20291>;
      <D.20291>:
      goto <D.20292>;
      <D.20287>:
      {
        char * end;

        end = age_alloc_buffers[age].end;
        if (end != 0B) goto <D.20293>; else goto <D.20294>;
        <D.20293>:
        <D.18557>:
        p = age_alloc_buffers[age].next;
        D.20288 = &age_alloc_buffers[age].next;
        D.20295 = InterlockedCompareExchangePointer (D.20288, end, p);
        if (D.20295 != p) goto <D.18557>; else goto <D.18558>;
        <D.18558>:
        sgen_clear_range (p, end);
        <D.20294>:
        age_alloc_buffers[age].end = 0B;
        mono_memory_write_barrier ();
        D.20296 = MAX_EXPR <aligned_objsize, 4096>;
        D.20297 = MAX_EXPR <aligned_objsize, 512>;
        p = sgen_fragment_allocator_par_range_alloc (&collector_allocator, D.20296, D.20297, &allocated_size);
        if (p != 0B) goto <D.20298>; else goto <D.20299>;
        <D.20298>:
        allocated_size.81 = allocated_size;
        D.20301 = p + allocated_size.81;
        set_age_in_range (p, D.20301, age);
        D.20281 = p + objsize;
        age_alloc_buffers[age].next = D.20281;
        mono_memory_write_barrier ();
        allocated_size.81 = allocated_size;
        D.20301 = p + allocated_size.81;
        age_alloc_buffers[age].end = D.20301;
        <D.20299>:
      }
      <D.20292>:
      pthread_mutex_unlock (&par_alloc_buffer_refill_mutex);
      D.20302 = p;
      return D.20302;
    }
  finally
    {
      allocated_size = {CLOBBER};
    }
}


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


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

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


split_nursery_serial_copy_object (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.84;
  int D.20313;
  struct FILE * gc_debug_file.85;
  char * iftmp.86;
  long unsigned int D.20320;
  long unsigned int D.20321;
  long unsigned int D.20324;
  long unsigned int D.20332;
  _Bool D.20333;
  long int D.20334;
  long int D.20335;
  int D.20342;
  void * D.20349;
  char * forwarded;
  char * obj;

  obj = *obj_slot;
  if (0 != 0) goto <D.20310>; else goto <D.20311>;
  <D.20310>:
  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.18665>:
  goto <D.18665>;
  <D.20311>:
  D.20313 = sgen_ptr_in_nursery (obj);
  if (D.20313 == 0) goto <D.20314>; else goto <D.20315>;
  <D.20314>:
  return;
  <D.20315>:
  if (0 != 0) goto <D.20316>; else goto <D.20317>;
  <D.20316>:
  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.20317>:
  D.20320 = MEM[(mword *)obj];
  D.20321 = D.20320 & 1;
  if (D.20321 != 0) goto <D.20322>; else goto <D.20323>;
  <D.20322>:
  D.20320 = MEM[(mword *)obj];
  D.20324 = D.20320 & 18446744073709551612;
  iftmp.86 = (char *) D.20324;
  goto <D.20325>;
  <D.20323>:
  iftmp.86 = 0B;
  <D.20325>:
  forwarded = iftmp.86;
  if (forwarded != 0B) goto <D.20326>; else goto <D.20327>;
  <D.20326>:
  if (0 != 0) goto <D.20328>; else goto <D.20329>;
  <D.20328>:
  monoeg_g_log (0B, 4, "forwarded object %p has no gc descriptor", forwarded);
  <D.18666>:
  goto <D.18666>;
  <D.20329>:
  if (0 != 0) goto <D.20330>; else goto <D.20331>;
  <D.20330>:
  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.20331>:
  *obj_slot = forwarded;
  return;
  <D.20327>:
  D.20320 = MEM[(mword *)obj];
  D.20332 = D.20320 & 2;
  D.20333 = D.20332 != 0;
  D.20334 = (long int) D.20333;
  D.20335 = __builtin_expect (D.20334, 0);
  if (D.20335 != 0) goto <D.20336>; else goto <D.20337>;
  <D.20336>:
  if (0 != 0) goto <D.20338>; else goto <D.20339>;
  <D.20338>:
  monoeg_g_log (0B, 4, "pinned object %p has no gc descriptor", obj);
  <D.18667>:
  goto <D.18667>;
  <D.20339>:
  if (0 != 0) goto <D.20340>; else goto <D.20341>;
  <D.20340>:
  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.20341>:
  return;
  <D.20337>:
  D.20342 = sgen_nursery_is_to_space (obj);
  if (D.20342 != 0) goto <D.20343>; else goto <D.20344>;
  <D.20343>:
  if (0 != 0) goto <D.20345>; else goto <D.20346>;
  <D.20345>:
  monoeg_g_log (0B, 4, "to space object %p has no gc descriptor", obj);
  <D.18668>:
  goto <D.18668>;
  <D.20346>:
  if (0 != 0) goto <D.20347>; else goto <D.20348>;
  <D.20347>:
  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.20348>:
  return;
  <D.20344>:
  D.20349 = copy_object_no_checks (obj, queue);
  *obj_slot = D.20349;
}


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);
}


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

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


handle_gc_param (const char * opt)
{
  int D.20354;
  char * D.20357;
  unsigned int percentage.88;
  unsigned int D.20359;
  struct _IO_FILE * stderr.89;
  float D.20363;
  float alloc_ratio.90;
  gboolean D.20365;
  int D.20366;
  char * D.20369;
  int promote_age.91;
  int promote_age.92;
  unsigned int promote_age.93;
  unsigned int D.20373;

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

    D.20357 = __builtin_strchr (opt, 61);
    arg = D.20357 + 1;
    percentage = atoi (arg);
    percentage.88 = (unsigned int) percentage;
    D.20359 = percentage.88 + 4294967295;
    if (D.20359 > 99) goto <D.20360>; else goto <D.20361>;
    <D.20360>:
    stderr.89 = stderr;
    fprintf (stderr.89, "alloc-ratio must be an integer in the range 1-100.\n");
    exit (1);
    <D.20361>:
    D.20363 = (float) percentage;
    alloc_ratio.90 = D.20363 / 1.0e+2;
    alloc_ratio = alloc_ratio.90;
    D.20365 = 1;
    return D.20365;
  }
  <D.20356>:
  D.20366 = monoeg_g_str_has_prefix (opt, "promotion-age=");
  if (D.20366 != 0) goto <D.20367>; else goto <D.20368>;
  <D.20367>:
  {
    const char * arg;

    D.20369 = __builtin_strchr (opt, 61);
    arg = D.20369 + 1;
    promote_age.91 = atoi (arg);
    promote_age = promote_age.91;
    promote_age.92 = promote_age;
    promote_age.93 = (unsigned int) promote_age.92;
    D.20373 = promote_age.93 + 4294967295;
    if (D.20373 > 13) goto <D.20374>; else goto <D.20375>;
    <D.20374>:
    stderr.89 = stderr;
    fprintf (stderr.89, "promotion-age must be an integer in the range 1-%d.\n", 14);
    exit (1);
    <D.20375>:
    D.20365 = 1;
    return D.20365;
  }
  <D.20368>:
  D.20365 = 0;
  return D.20365;
}


atoi (const char * __nptr)
{
  int D.20377;
  long int D.20378;

  D.20378 = strtol (__nptr, 0B, 10);
  D.20377 = (int) D.20378;
  return D.20377;
}


init_nursery (struct SgenFragmentAllocator * allocator, char * start, char * end)
{
  long int end.94;
  long int start.95;
  long int D.20382;
  float D.20383;
  float alloc_ratio.96;
  float D.20385;
  long unsigned int D.20386;
  long unsigned int start.97;
  long unsigned int D.20388;
  long unsigned int D.20389;
  char * promotion_barrier.98;
  char * promotion_barrier.99;
  long int D.20392;
  int region_age_size.100;
  int region_age_size.101;
  long unsigned int D.20395;
  void * region_age.102;
  int alloc_quote;

  end.94 = (long int) end;
  start.95 = (long int) start;
  D.20382 = end.94 - start.95;
  D.20383 = (float) D.20382;
  alloc_ratio.96 = alloc_ratio;
  D.20385 = D.20383 * alloc_ratio.96;
  alloc_quote = (int) D.20385;
  D.20386 = (long unsigned int) alloc_quote;
  start.97 = (long unsigned int) start;
  D.20388 = D.20386 + start.97;
  D.20389 = D.20388 & 18446744073709551608;
  promotion_barrier.98 = (char *) D.20389;
  promotion_barrier = promotion_barrier.98;
  promotion_barrier.99 = promotion_barrier;
  sgen_fragment_allocator_add (allocator, start, promotion_barrier.99);
  promotion_barrier.99 = promotion_barrier;
  sgen_fragment_allocator_add (&collector_allocator, promotion_barrier.99, end);
  end.94 = (long int) end;
  start.95 = (long int) start;
  D.20382 = end.94 - start.95;
  D.20392 = D.20382 >> 9;
  region_age_size.100 = (int) D.20392;
  region_age_size = region_age_size.100;
  region_age_size.101 = region_age_size;
  D.20395 = (long unsigned int) region_age_size.101;
  region_age.102 = monoeg_malloc0 (D.20395);
  region_age = region_age.102;
}


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


fragment_list_split (struct SgenFragmentAllocator * allocator)
{
  char * D.20397;
  char * promotion_barrier.103;
  char * D.20401;
  struct SgenFragment * D.20404;
  struct SgenFragment * D.20405;
  char * D.20406;
  char * D.20407;
  _Bool D.20408;
  long int D.20409;
  long int D.20410;
  struct SgenFragment * D.20413;
  struct SgenFragment * D.20416;
  struct SgenFragment * prev;
  struct SgenFragment * list;

  prev = 0B;
  list = allocator->region_head;
  goto <D.18531>;
  <D.18530>:
  D.20397 = list->fragment_end;
  promotion_barrier.103 = promotion_barrier;
  if (D.20397 > promotion_barrier.103) goto <D.20399>; else goto <D.20400>;
  <D.20399>:
  D.20401 = list->fragment_start;
  promotion_barrier.103 = promotion_barrier;
  if (D.20401 < promotion_barrier.103) goto <D.20402>; else goto <D.20403>;
  <D.20402>:
  {
    struct SgenFragment * res;

    res = sgen_fragment_allocator_alloc ();
    promotion_barrier.103 = promotion_barrier;
    res->fragment_start = promotion_barrier.103;
    promotion_barrier.103 = promotion_barrier;
    res->fragment_next = promotion_barrier.103;
    D.20397 = list->fragment_end;
    res->fragment_end = D.20397;
    D.20404 = list->next;
    res->next = D.20404;
    D.20405 = list->next_in_order;
    res->next_in_order = D.20405;
    D.20406 = res->fragment_end;
    D.20407 = res->fragment_start;
    D.20408 = D.20406 <= D.20407;
    D.20409 = (long int) D.20408;
    D.20410 = __builtin_expect (D.20409, 0);
    if (D.20410 != 0) goto <D.20411>; else goto <D.20412>;
    <D.20411>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-split-nursery.c", 220, "res->fragment_end > res->fragment_start");
    <D.20412>:
    promotion_barrier.103 = promotion_barrier;
    list->fragment_end = promotion_barrier.103;
    list->next_in_order = 0B;
    D.20405 = list->next_in_order;
    list->next = D.20405;
    D.20401 = list->fragment_start;
    D.20397 = list->fragment_end;
    set_age_in_range (D.20401, D.20397, 0);
    allocator->alloc_head = res;
    D.20413 = allocator->alloc_head;
    allocator->region_head = D.20413;
    return;
  }
  <D.20403>:
  if (prev != 0B) goto <D.20414>; else goto <D.20415>;
  <D.20414>:
  prev->next_in_order = 0B;
  D.20416 = prev->next_in_order;
  prev->next = D.20416;
  <D.20415>:
  allocator->alloc_head = list;
  D.20413 = allocator->alloc_head;
  allocator->region_head = D.20413;
  return;
  <D.20400>:
  D.20401 = list->fragment_start;
  D.20397 = list->fragment_end;
  set_age_in_range (D.20401, D.20397, 0);
  prev = list;
  list = list->next;
  <D.18531>:
  if (list != 0B) goto <D.18530>; else goto <D.18532>;
  <D.18532>:
  allocator->alloc_head = 0B;
  D.20413 = allocator->alloc_head;
  allocator->region_head = D.20413;
}


build_fragments_release_exclude_head ()
{
  sgen_fragment_allocator_release (&collector_allocator);
}


build_fragments_get_exclude_head ()
{
  char * D.20418;
  char * D.20421;
  struct SgenFragment * D.20422;
  int i;

  i = 0;
  goto <D.18585>;
  <D.18584>:
  D.20418 = age_alloc_buffers[i].end;
  if (D.20418 != 0B) goto <D.20419>; else goto <D.20420>;
  <D.20419>:
  D.20421 = age_alloc_buffers[i].next;
  D.20418 = age_alloc_buffers[i].end;
  sgen_clear_range (D.20421, D.20418);
  <D.20420>:
  i = i + 1;
  <D.18585>:
  if (i <= 14) goto <D.18584>; else goto <D.18586>;
  <D.18586>:
  D.20422 = collector_allocator.region_head;
  return D.20422;
}


clear_fragments ()
{
  sgen_clear_allocator_fragments (&collector_allocator);
}


prepare_to_space (char * to_space_bitmap, int space_bitmap_size)
{
  long unsigned int D.20424;
  char * D.20425;
  long unsigned int D.20426;
  long unsigned int D.20427;
  long unsigned int D.20428;
  char * D.20429;
  long unsigned int D.20430;
  long unsigned int D.20431;
  long int end.104;
  long int start.105;
  long int D.20434;
  char * D.20437;
  struct SgenFragment * D.20438;
  struct SgenFragment * * previous;
  struct SgenFragment * frag;

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

    D.20425 = frag->fragment_next;
    D.20426 = (long unsigned int) D.20425;
    D.20427 = D.20426 + 511;
    D.20428 = D.20427 & 18446744073709551104;
    start = (char *) D.20428;
    D.20429 = frag->fragment_end;
    D.20430 = (long unsigned int) D.20429;
    D.20431 = D.20430 & 18446744073709551104;
    end = (char *) D.20431;
    end.104 = (long int) end;
    start.105 = (long int) start;
    D.20434 = end.104 - start.105;
    if (D.20434 <= 511) goto <D.20435>; else goto <D.20436>;
    <D.20435>:
    D.20425 = frag->fragment_next;
    D.20429 = frag->fragment_end;
    sgen_clear_range (D.20425, D.20429);
    D.20437 = frag->fragment_start;
    frag->fragment_end = D.20437;
    D.20429 = frag->fragment_end;
    frag->fragment_next = D.20429;
    D.20438 = frag->next;
    *previous = D.20438;
    // predicted unlikely by continue predictor.
    goto <D.18601>;
    <D.20436>:
    sgen_clear_range (start, end);
    D.20425 = frag->fragment_next;
    if (D.20425 != start) goto <D.20439>; else goto <D.20440>;
    <D.20439>:
    D.20425 = frag->fragment_next;
    sgen_clear_range (D.20425, start);
    <D.20440>:
    D.20429 = frag->fragment_end;
    if (D.20429 != end) goto <D.20441>; else goto <D.20442>;
    <D.20441>:
    D.20429 = frag->fragment_end;
    sgen_clear_range (end, D.20429);
    <D.20442>:
    frag->fragment_next = start;
    D.20425 = frag->fragment_next;
    frag->fragment_start = D.20425;
    frag->fragment_end = end;
    mark_bits_in_range (to_space_bitmap, start, end);
    previous = &frag->next;
  }
  <D.18601>:
  frag = *previous;
  <D.18603>:
  if (frag != 0B) goto <D.18602>; else goto <D.18604>;
  <D.18604>:
}


mark_bits_in_range (char * space_bitmap, char * start, char * end)
{
  long unsigned int start.106;
  long unsigned int D.20444;
  long unsigned int end.107;
  long unsigned int D.20446;
  long unsigned int D.20447;

  start.106 = (long unsigned int) start;
  D.20444 = start.106 & 18446744073709551104;
  start = (char *) D.20444;
  end.107 = (long unsigned int) end;
  D.20446 = end.107 + 511;
  D.20447 = D.20446 & 18446744073709551104;
  end = (char *) D.20447;
  goto <D.18522>;
  <D.18521>:
  mark_bit (space_bitmap, start);
  start = start + 512;
  <D.18522>:
  if (start < end) goto <D.18521>; else goto <D.18523>;
  <D.18523>:
}


mark_bit (char * space_bitmap, char * pos)
{
  long int pos.108;
  char * sgen_nursery_start.109;
  long int sgen_nursery_start.110;
  long int D.20451;
  long int D.20452;
  int sgen_space_bitmap_size.111;
  _Bool D.20454;
  long int D.20455;
  long int D.20456;
  sizetype D.20459;
  char * D.20460;
  char D.20461;
  signed char D.20462;
  int D.20463;
  signed char D.20464;
  signed char D.20465;
  char D.20466;
  int idx;
  int byte;
  int bit;

  pos.108 = (long int) pos;
  sgen_nursery_start.109 = sgen_nursery_start;
  sgen_nursery_start.110 = (long int) sgen_nursery_start.109;
  D.20451 = pos.108 - sgen_nursery_start.110;
  D.20452 = D.20451 >> 9;
  idx = (int) D.20452;
  byte = idx / 8;
  bit = idx & 7;
  sgen_space_bitmap_size.111 = sgen_space_bitmap_size;
  D.20454 = byte >= sgen_space_bitmap_size.111;
  D.20455 = (long int) D.20454;
  D.20456 = __builtin_expect (D.20455, 0);
  if (D.20456 != 0) goto <D.20457>; else goto <D.20458>;
  <D.20457>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-split-nursery.c", 182, "byte < sgen_space_bitmap_size");
  <D.20458>:
  D.20459 = (sizetype) byte;
  D.20460 = space_bitmap + D.20459;
  D.20459 = (sizetype) byte;
  D.20460 = space_bitmap + D.20459;
  D.20461 = *D.20460;
  D.20462 = (signed char) D.20461;
  D.20463 = 1 << bit;
  D.20464 = (signed char) D.20463;
  D.20465 = D.20462 | D.20464;
  D.20466 = (char) D.20465;
  *D.20460 = D.20466;
}


minor_par_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int D.20467;
  char * D.20470;
  void * (*<T2f12>) (struct MonoVTable *, int, gboolean) D.20471;
  int D.20472;

  D.20467 = sgen_ptr_in_nursery (obj);
  if (D.20467 == 0) goto <D.20468>; else goto <D.20469>;
  <D.20468>:
  D.20471 = major_collector.par_alloc_object;
  D.20472 = (int) objsize;
  D.20470 = D.20471 (vtable, D.20472, has_references);
  return D.20470;
  <D.20469>:
  D.20470 = par_alloc_for_promotion (vtable, obj, objsize, has_references);
  return D.20470;
}


minor_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int D.20474;
  char * D.20477;
  void * (*<T2f12>) (struct MonoVTable *, int, gboolean) D.20478;
  int D.20479;

  D.20474 = sgen_ptr_in_nursery (obj);
  if (D.20474 == 0) goto <D.20475>; else goto <D.20476>;
  <D.20475>:
  D.20478 = major_collector.alloc_object;
  D.20479 = (int) objsize;
  D.20477 = D.20478 (vtable, D.20479, has_references);
  return D.20477;
  <D.20476>:
  D.20477 = alloc_for_promotion (vtable, obj, objsize, has_references);
  return D.20477;
}