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.18549;
  long unsigned int D.18550;
  long unsigned int D.18553;
  long unsigned int D.18554;
  long unsigned int D.18555;
  long unsigned int D.18556;
  long unsigned int D.18557;
  long unsigned int D.18558;
  void * D.18563;
  struct FILE * gc_debug_file.0;
  long unsigned int D.18573;
  long unsigned int D.18574;
  int D.18575;
  void * D.18580;
  long unsigned int D.18583;
  long unsigned int D.18584;
  int D.18585;
  long unsigned int D.18592;
  long unsigned int D.18595;
  int D.18596;
  int D.18597;
  unsigned int D.18600;
  unsigned int el_size.1;
  unsigned int D.18602;
  sizetype D.18603;
  void * D.18608;
  int D.18614;
  int D.18615;
  long unsigned int D.18616;
  long unsigned int D.18617;
  long unsigned int D.18618;
  long unsigned int D.18619;
  void * * D.18620;
  void * D.18625;
  sizetype D.18628;
  long unsigned int D.18632;
  void * D.18639;
  long unsigned int D.18642;
  void * D.18649;
  long unsigned int D.18652;
  unsigned int D.18653;
  unsigned int D.18654;
  struct MonoVTable * D.18657;
  struct MonoClass * D.18658;
  const char * D.18659;
  const char * D.18660;
  gsize * bitmap_data.2;
  long unsigned int D.18662;
  void * D.18669;
  int bwords.3;

  start = start + 18446744073709551600;
  D.18549 = desc & 7;
  switch (D.18549) <default: <D.18544>, case 1: <D.18470>, case 2: <D.18479>, case 3: <D.18529>, case 4: <D.18489>, case 5: <D.18522>, case 7: <D.18543>>
  <D.18470>:
  D.18550 = desc & 4294901760;
  if (D.18550 != 0) goto <D.18551>; else goto <D.18552>;
  <D.18551>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.18553 = desc >> 16;
    D.18554 = D.18553 & 255;
    D.18555 = D.18554 * 8;
    _objptr = _objptr + D.18555;
    D.18556 = desc >> 24;
    D.18557 = D.18556 & 255;
    D.18558 = D.18557 * 8;
    _objptr_end = _objptr + D.18558;
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.18559>; else goto <D.18560>;
      <D.18559>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.18561>; else goto <D.18562>;
      <D.18561>:
      D.18563 = *_objptr;
      if (D.18563 != __old) goto <D.18564>; else goto <D.18565>;
      <D.18564>:
      D.18563 = *_objptr;
      gc_debug_file.0 = gc_debug_file;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18563, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.18565>:
      <D.18562>:
      <D.18560>:
    }
    _objptr = _objptr + 8;
    goto <D.18476>;
    <D.18475>:
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.18567>; else goto <D.18568>;
      <D.18567>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.18569>; else goto <D.18570>;
      <D.18569>:
      D.18563 = *_objptr;
      if (D.18563 != __old) goto <D.18571>; else goto <D.18572>;
      <D.18571>:
      D.18563 = *_objptr;
      gc_debug_file.0 = gc_debug_file;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18563, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.18572>:
      <D.18570>:
      <D.18568>:
    }
    _objptr = _objptr + 8;
    <D.18476>:
    if (_objptr < _objptr_end) goto <D.18475>; else goto <D.18477>;
    <D.18477>:
  }
  <D.18552>:
  goto <D.18478>;
  <D.18479>:
  {
    void * * _objptr;
    gsize _bmap;

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

      _index = __builtin_ctzl (_bmap);
      D.18573 = (long unsigned int) _index;
      D.18574 = D.18573 * 8;
      _objptr = _objptr + D.18574;
      D.18575 = _index + 1;
      _bmap = _bmap >> D.18575;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.18576>; else goto <D.18577>;
        <D.18576>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.18578>; else goto <D.18579>;
        <D.18578>:
        D.18580 = *_objptr;
        if (D.18580 != __old) goto <D.18581>; else goto <D.18582>;
        <D.18581>:
        D.18580 = *_objptr;
        gc_debug_file.0 = gc_debug_file;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18580, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.18582>:
        <D.18579>:
        <D.18577>:
      }
      _objptr = _objptr + 8;
    }
    goto <D.18487>;
    <D.18486>:
    {
      int _index;

      _index = __builtin_ctzl (_bmap);
      D.18583 = (long unsigned int) _index;
      D.18584 = D.18583 * 8;
      _objptr = _objptr + D.18584;
      D.18585 = _index + 1;
      _bmap = _bmap >> D.18585;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.18586>; else goto <D.18587>;
        <D.18586>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.18588>; else goto <D.18589>;
        <D.18588>:
        D.18580 = *_objptr;
        if (D.18580 != __old) goto <D.18590>; else goto <D.18591>;
        <D.18590>:
        D.18580 = *_objptr;
        gc_debug_file.0 = gc_debug_file;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18580, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.18591>:
        <D.18589>:
        <D.18587>:
      }
      _objptr = _objptr + 8;
    }
    <D.18487>:
    if (_bmap != 0) goto <D.18486>; else goto <D.18488>;
    <D.18488>:
  }
  goto <D.18478>;
  <D.18489>:
  D.18592 = desc & 4294950912;
  if (D.18592 != 0) goto <D.18593>; else goto <D.18594>;
  <D.18593>:
  {
    int el_size;
    int etype;

    D.18595 = desc >> 3;
    D.18596 = (int) D.18595;
    el_size = D.18596 & 1023;
    D.18597 = (int) desc;
    etype = D.18597 & 49152;
    if (etype == 16384) goto <D.18598>; else goto <D.18599>;
    <D.18598>:
    {
      void * * p;
      void * * end_refs;

      p = start + 32;
      D.18600 = MEM[(struct MonoArray *)start].max_length;
      el_size.1 = (unsigned int) el_size;
      D.18602 = D.18600 * el_size.1;
      D.18603 = (sizetype) D.18602;
      end_refs = p + D.18603;
      goto <D.18496>;
      <D.18495>:
      {
        void * __old;

        __old = *p;
        if (__old != 0B) goto <D.18604>; else goto <D.18605>;
        <D.18604>:
        split_nursery_serial_copy_object_from_obj (p, queue);
        if (0 != 0) goto <D.18606>; else goto <D.18607>;
        <D.18606>:
        D.18608 = *p;
        if (D.18608 != __old) goto <D.18609>; else goto <D.18610>;
        <D.18609>:
        D.18608 = *p;
        gc_debug_file.0 = gc_debug_file;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", p, D.18608, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.18610>:
        <D.18607>:
        <D.18605>:
      }
      p = p + 8;
      <D.18496>:
      if (p < end_refs) goto <D.18495>; else goto <D.18497>;
      <D.18497>:
    }
    goto <D.18611>;
    <D.18599>:
    if (etype == 32768) goto <D.18612>; else goto <D.18613>;
    <D.18612>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.18553 = desc >> 16;
      D.18614 = (int) D.18553;
      offset = D.18614 & 255;
      D.18556 = desc >> 24;
      D.18615 = (int) D.18556;
      num_refs = D.18615 & 255;
      e_start = start + 32;
      D.18600 = MEM[(struct MonoArray *)start].max_length;
      el_size.1 = (unsigned int) el_size;
      D.18602 = D.18600 * el_size.1;
      D.18603 = (sizetype) D.18602;
      e_end = e_start + D.18603;
      goto <D.18509>;
      <D.18508>:
      {
        void * * p;
        int i;

        p = e_start;
        D.18616 = (long unsigned int) offset;
        D.18617 = D.18616 * 8;
        p = p + D.18617;
        i = 0;
        goto <D.18506>;
        <D.18505>:
        {
          void * __old;

          D.18618 = (long unsigned int) i;
          D.18619 = D.18618 * 8;
          D.18620 = p + D.18619;
          __old = *D.18620;
          if (__old != 0B) goto <D.18621>; else goto <D.18622>;
          <D.18621>:
          D.18618 = (long unsigned int) i;
          D.18619 = D.18618 * 8;
          D.18620 = p + D.18619;
          split_nursery_serial_copy_object_from_obj (D.18620, queue);
          if (0 != 0) goto <D.18623>; else goto <D.18624>;
          <D.18623>:
          D.18618 = (long unsigned int) i;
          D.18619 = D.18618 * 8;
          D.18620 = p + D.18619;
          D.18625 = *D.18620;
          if (D.18625 != __old) goto <D.18626>; else goto <D.18627>;
          <D.18626>:
          D.18618 = (long unsigned int) i;
          D.18619 = D.18618 * 8;
          D.18620 = p + D.18619;
          D.18625 = *D.18620;
          D.18618 = (long unsigned int) i;
          D.18619 = D.18618 * 8;
          D.18620 = p + D.18619;
          gc_debug_file.0 = gc_debug_file;
          fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", D.18620, D.18625, __old);
          gc_debug_file.0 = gc_debug_file;
          fflush (gc_debug_file.0);
          <D.18627>:
          <D.18624>:
          <D.18622>:
        }
        i = i + 1;
        <D.18506>:
        if (i < num_refs) goto <D.18505>; else goto <D.18507>;
        <D.18507>:
        D.18628 = (sizetype) el_size;
        e_start = e_start + D.18628;
      }
      <D.18509>:
      if (e_start < e_end) goto <D.18508>; else goto <D.18510>;
      <D.18510>:
    }
    goto <D.18629>;
    <D.18613>:
    if (etype == 49152) goto <D.18630>; else goto <D.18631>;
    <D.18630>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 32;
      D.18600 = MEM[(struct MonoArray *)start].max_length;
      el_size.1 = (unsigned int) el_size;
      D.18602 = D.18600 * el_size.1;
      D.18603 = (sizetype) D.18602;
      e_end = e_start + D.18603;
      goto <D.18520>;
      <D.18519>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.18517>;
        <D.18516>:
        D.18632 = _bmap & 1;
        if (D.18632 != 0) goto <D.18633>; else goto <D.18634>;
        <D.18633>:
        {
          void * __old;

          __old = *p;
          if (__old != 0B) goto <D.18635>; else goto <D.18636>;
          <D.18635>:
          split_nursery_serial_copy_object_from_obj (p, queue);
          if (0 != 0) goto <D.18637>; else goto <D.18638>;
          <D.18637>:
          D.18639 = *p;
          if (D.18639 != __old) goto <D.18640>; else goto <D.18641>;
          <D.18640>:
          D.18639 = *p;
          gc_debug_file.0 = gc_debug_file;
          fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", p, D.18639, __old);
          gc_debug_file.0 = gc_debug_file;
          fflush (gc_debug_file.0);
          <D.18641>:
          <D.18638>:
          <D.18636>:
        }
        <D.18634>:
        _bmap = _bmap >> 1;
        p = p + 8;
        <D.18517>:
        if (_bmap != 0) goto <D.18516>; else goto <D.18518>;
        <D.18518>:
        D.18628 = (sizetype) el_size;
        e_start = e_start + D.18628;
      }
      <D.18520>:
      if (e_start < e_end) goto <D.18519>; else goto <D.18521>;
      <D.18521>:
    }
    <D.18631>:
    <D.18629>:
    <D.18611>:
  }
  <D.18594>:
  goto <D.18478>;
  <D.18522>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 3;
    _objptr = _objptr + 16;
    goto <D.18527>;
    <D.18526>:
    D.18642 = _bmap & 1;
    if (D.18642 != 0) goto <D.18643>; else goto <D.18644>;
    <D.18643>:
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.18645>; else goto <D.18646>;
      <D.18645>:
      split_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.18647>; else goto <D.18648>;
      <D.18647>:
      D.18649 = *_objptr;
      if (D.18649 != __old) goto <D.18650>; else goto <D.18651>;
      <D.18650>:
      D.18649 = *_objptr;
      gc_debug_file.0 = gc_debug_file;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18649, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.18651>:
      <D.18648>:
      <D.18646>:
    }
    <D.18644>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 8;
    <D.18527>:
    if (_bmap != 0) goto <D.18526>; else goto <D.18528>;
    <D.18528>:
  }
  goto <D.18478>;
  <D.18529>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.18652 = *bitmap_data;
    D.18653 = (unsigned int) D.18652;
    D.18654 = D.18653 + 4294967295;
    bwords = (int) D.18654;
    start_run = _objptr;
    bitmap_data = bitmap_data + 8;
    if (0 != 0) goto <D.18655>; else goto <D.18656>;
    <D.18655>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.18657 = myobj->vtable;
      D.18658 = D.18657->klass;
      D.18659 = D.18658->name;
      D.18657 = myobj->vtable;
      D.18658 = D.18657->klass;
      D.18660 = D.18658->name_space;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18660, D.18659);
    }
    <D.18656>:
    goto <D.18541>;
    <D.18540>:
    {
      gsize _bmap;

      bitmap_data.2 = bitmap_data;
      bitmap_data = bitmap_data.2 + 8;
      _bmap = *bitmap_data.2;
      _objptr = start_run;
      goto <D.18538>;
      <D.18537>:
      D.18662 = _bmap & 1;
      if (D.18662 != 0) goto <D.18663>; else goto <D.18664>;
      <D.18663>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.18665>; else goto <D.18666>;
        <D.18665>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.18667>; else goto <D.18668>;
        <D.18667>:
        D.18669 = *_objptr;
        if (D.18669 != __old) goto <D.18670>; else goto <D.18671>;
        <D.18670>:
        D.18669 = *_objptr;
        gc_debug_file.0 = gc_debug_file;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.18669, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.18671>:
        <D.18668>:
        <D.18666>:
      }
      <D.18664>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18538>:
      if (_bmap != 0) goto <D.18537>; else goto <D.18539>;
      <D.18539>:
      start_run = start_run + 512;
    }
    <D.18541>:
    bwords.3 = bwords;
    bwords = bwords.3 + -1;
    if (bwords.3 > 0) goto <D.18540>; else goto <D.18542>;
    <D.18542>:
  }
  goto <D.18478>;
  <D.18543>:
  goto <D.18478>;
  <D.18544>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.18478>:
}


split_nursery_serial_copy_object_from_obj (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.4;
  int D.18677;
  struct FILE * gc_debug_file.5;
  char * iftmp.6;
  long unsigned int D.18684;
  long unsigned int D.18685;
  long unsigned int D.18688;
  int iftmp.7;
  int D.18699;
  int D.18701;
  _Bool D.18703;
  long int D.18704;
  long int D.18705;
  long unsigned int D.18708;
  _Bool D.18709;
  long int D.18710;
  long int D.18711;
  int D.18718;
  int D.18721;
  int D.18728;
  int iftmp.8;
  int D.18734;
  int D.18736;
  _Bool D.18738;
  long int D.18739;
  long int D.18740;
  char * forwarded;
  char * obj;
  void * copy;

  obj = *obj_slot;
  if (0 != 0) goto <D.18674>; else goto <D.18675>;
  <D.18674>:
  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.18146>:
  goto <D.18146>;
  <D.18675>:
  D.18677 = sgen_ptr_in_nursery (obj);
  if (D.18677 == 0) goto <D.18678>; else goto <D.18679>;
  <D.18678>:
  return;
  <D.18679>:
  if (0 != 0) goto <D.18680>; else goto <D.18681>;
  <D.18680>:
  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.18681>:
  D.18684 = MEM[(mword *)obj];
  D.18685 = D.18684 & 1;
  if (D.18685 != 0) goto <D.18686>; else goto <D.18687>;
  <D.18686>:
  D.18684 = MEM[(mword *)obj];
  D.18688 = D.18684 & 18446744073709551612;
  iftmp.6 = (char *) D.18688;
  goto <D.18689>;
  <D.18687>:
  iftmp.6 = 0B;
  <D.18689>:
  forwarded = iftmp.6;
  if (forwarded != 0B) goto <D.18690>; else goto <D.18691>;
  <D.18690>:
  if (0 != 0) goto <D.18692>; else goto <D.18693>;
  <D.18692>:
  monoeg_g_log (0B, 4, "forwarded object %p has no gc descriptor", forwarded);
  <D.18147>:
  goto <D.18147>;
  <D.18693>:
  if (0 != 0) goto <D.18694>; else goto <D.18695>;
  <D.18694>:
  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.18695>:
  *obj_slot = forwarded;
  D.18699 = sgen_ptr_in_nursery (forwarded);
  if (D.18699 != 0) goto <D.18700>; else goto <D.18697>;
  <D.18700>:
  D.18701 = sgen_ptr_in_nursery (obj_slot);
  if (D.18701 == 0) goto <D.18702>; else goto <D.18697>;
  <D.18702>:
  iftmp.7 = 1;
  goto <D.18698>;
  <D.18697>:
  iftmp.7 = 0;
  <D.18698>:
  D.18703 = iftmp.7 != 0;
  D.18704 = (long int) D.18703;
  D.18705 = __builtin_expect (D.18704, 0);
  if (D.18705 != 0) goto <D.18706>; else goto <D.18707>;
  <D.18706>:
  sgen_add_to_global_remset (obj_slot, forwarded);
  <D.18707>:
  return;
  <D.18691>:
  D.18684 = MEM[(mword *)obj];
  D.18708 = D.18684 & 2;
  D.18709 = D.18708 != 0;
  D.18710 = (long int) D.18709;
  D.18711 = __builtin_expect (D.18710, 0);
  if (D.18711 != 0) goto <D.18712>; else goto <D.18713>;
  <D.18712>:
  if (0 != 0) goto <D.18714>; else goto <D.18715>;
  <D.18714>:
  monoeg_g_log (0B, 4, "pinned object %p has no gc descriptor", obj);
  <D.18148>:
  goto <D.18148>;
  <D.18715>:
  if (0 != 0) goto <D.18716>; else goto <D.18717>;
  <D.18716>:
  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.18717>:
  D.18718 = sgen_ptr_in_nursery (obj_slot);
  if (D.18718 == 0) goto <D.18719>; else goto <D.18720>;
  <D.18719>:
  sgen_add_to_global_remset (obj_slot, obj);
  <D.18720>:
  return;
  <D.18713>:
  D.18721 = sgen_nursery_is_to_space (obj);
  if (D.18721 != 0) goto <D.18722>; else goto <D.18723>;
  <D.18722>:
  if (0 != 0) goto <D.18724>; else goto <D.18725>;
  <D.18724>:
  monoeg_g_log (0B, 4, "to space object %p has no gc descriptor", obj);
  <D.18149>:
  goto <D.18149>;
  <D.18725>:
  if (0 != 0) goto <D.18726>; else goto <D.18727>;
  <D.18726>:
  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.18727>:
  D.18728 = sgen_ptr_in_nursery (obj_slot);
  if (D.18728 == 0) goto <D.18729>; else goto <D.18730>;
  <D.18729>:
  sgen_add_to_global_remset (obj_slot, obj);
  <D.18730>:
  return;
  <D.18723>:
  copy = copy_object_no_checks (obj, queue);
  *obj_slot = copy;
  D.18734 = sgen_ptr_in_nursery (copy);
  if (D.18734 != 0) goto <D.18735>; else goto <D.18732>;
  <D.18735>:
  D.18736 = sgen_ptr_in_nursery (obj_slot);
  if (D.18736 == 0) goto <D.18737>; else goto <D.18732>;
  <D.18737>:
  iftmp.8 = 1;
  goto <D.18733>;
  <D.18732>:
  iftmp.8 = 0;
  <D.18733>:
  D.18738 = iftmp.8 != 0;
  D.18739 = (long int) D.18738;
  D.18740 = __builtin_expect (D.18739, 0);
  if (D.18740 != 0) goto <D.18741>; else goto <D.18742>;
  <D.18741>:
  sgen_add_to_global_remset (obj_slot, copy);
  <D.18742>:
}


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.18747;
  long int D.18748;
  int D.18749;
  _Bool D.18750;
  long int D.18751;
  long int D.18752;
  char * D.18755;
  char * D.18756;
  int sgen_space_bitmap_size.12;
  _Bool D.18758;
  long int D.18759;
  long int D.18760;
  gboolean D.18763;
  char * sgen_space_bitmap.13;
  sizetype D.18765;
  char * D.18766;
  char D.18767;
  int D.18768;
  int D.18769;
  int D.18770;
  _Bool D.18771;
  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.18747 = object.9 - sgen_nursery_start.11;
  D.18748 = D.18747 >> 9;
  idx = (int) D.18748;
  byte = idx / 8;
  bit = idx & 7;
  D.18749 = sgen_ptr_in_nursery (object);
  D.18750 = D.18749 == 0;
  D.18751 = (long int) D.18750;
  D.18752 = __builtin_expect (D.18751, 0);
  if (D.18752 != 0) goto <D.18753>; else goto <D.18754>;
  <D.18753>:
  D.18755 = sgen_get_nursery_end ();
  D.18756 = sgen_get_nursery_start ();
  monoeg_g_log (0B, 4, "object %p is not in nursery [%p - %p]", object, D.18756, D.18755);
  <D.17432>:
  goto <D.17432>;
  <D.18754>:
  sgen_space_bitmap_size.12 = sgen_space_bitmap_size;
  D.18758 = byte >= sgen_space_bitmap_size.12;
  D.18759 = (long int) D.18758;
  D.18760 = __builtin_expect (D.18759, 0);
  if (D.18760 != 0) goto <D.18761>; else goto <D.18762>;
  <D.18761>:
  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.17433>:
  goto <D.17433>;
  <D.18762>:
  sgen_space_bitmap.13 = sgen_space_bitmap;
  D.18765 = (sizetype) byte;
  D.18766 = sgen_space_bitmap.13 + D.18765;
  D.18767 = *D.18766;
  D.18768 = (int) D.18767;
  D.18769 = D.18768 >> bit;
  D.18770 = D.18769 & 1;
  D.18771 = D.18770 != 0;
  D.18763 = (gboolean) D.18771;
  return D.18763;
}


sgen_get_nursery_end ()
{
  char * D.18773;

  D.18773 = sgen_nursery_end;
  return D.18773;
}


sgen_get_nursery_start ()
{
  char * D.18775;

  D.18775 = sgen_nursery_start;
  return D.18775;
}


copy_object_no_checks (void * obj, struct SgenGrayQueue * queue)
{
  void * D.18777;
  long unsigned int D.18778;
  unsigned int D.18779;
  unsigned int D.18780;
  long unsigned int D.18781;
  _Bool D.18782;
  long int D.18783;
  long int D.18784;
  void * D.18787;
  struct SgenGrayQueue * iftmp.14;
  long unsigned int destination.15;
  long unsigned int D.18793;
  struct MonoVTable * vt;
  gboolean has_references;
  mword objsize;
  char * destination;

  vt = MEM[(struct MonoObject *)obj].vtable;
  D.18777 = vt->gc_descr;
  D.18778 = (long unsigned int) D.18777;
  has_references = sgen_gc_descr_has_references (D.18778);
  D.18779 = sgen_par_object_get_size (vt, obj);
  D.18780 = D.18779 + 7;
  D.18781 = (long unsigned int) D.18780;
  objsize = D.18781 & 4294967288;
  destination = alloc_for_promotion (vt, obj, objsize, has_references);
  D.18782 = destination == 0B;
  D.18783 = (long int) D.18782;
  D.18784 = __builtin_expect (D.18783, 0);
  if (D.18784 != 0) goto <D.18785>; else goto <D.18786>;
  <D.18785>:
  sgen_pin_object (obj, queue);
  sgen_set_pinned_from_failed_allocation (objsize);
  D.18787 = obj;
  return D.18787;
  <D.18786>:
  if (has_references != 0) goto <D.18789>; else goto <D.18790>;
  <D.18789>:
  iftmp.14 = queue;
  goto <D.18791>;
  <D.18790>:
  iftmp.14 = 0B;
  <D.18791>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.14);
  destination.15 = (long unsigned int) destination;
  D.18793 = destination.15 | 1;
  MEM[(mword *)obj] = D.18793;
  D.18787 = destination;
  return D.18787;
}


sgen_gc_descr_has_references (mword desc)
{
  long unsigned int D.18795;
  gboolean D.18798;
  long unsigned int D.18799;
  long unsigned int D.18802;

  D.18795 = desc & 4294901767;
  if (D.18795 == 1) goto <D.18796>; else goto <D.18797>;
  <D.18796>:
  D.18798 = 0;
  return D.18798;
  <D.18797>:
  D.18799 = desc & 49159;
  if (D.18799 == 4) goto <D.18800>; else goto <D.18801>;
  <D.18800>:
  D.18798 = 0;
  return D.18798;
  <D.18801>:
  D.18802 = desc & 7;
  if (D.18802 == 7) goto <D.18803>; else goto <D.18804>;
  <D.18803>:
  D.18798 = 0;
  return D.18798;
  <D.18804>:
  D.18798 = 1;
  return D.18798;
}


sgen_par_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  void * D.18806;
  long unsigned int D.18807;
  guint D.18812;
  int D.18813;
  int D.18814;
  unsigned int D.18815;
  long unsigned int D.18818;
  int D.18819;
  unsigned int D.18820;
  unsigned int element_size.16;
  unsigned int D.18822;
  long unsigned int D.18823;
  long unsigned int D.18824;
  struct MonoClass * D.18827;
  unsigned char D.18828;
  long unsigned int D.18829;
  long unsigned int D.18830;
  mword descr;
  mword type;

  D.18806 = vtable->gc_descr;
  descr = (mword) D.18806;
  type = descr & 7;
  D.18807 = type + 18446744073709551615;
  if (D.18807 <= 1) goto <D.18808>; else goto <D.18809>;
  <D.18808>:
  {
    mword size;

    size = descr & 65528;
    if (size == 0) goto <D.18810>; else goto <D.18811>;
    <D.18810>:
    D.18813 = MEM[(struct MonoString *)o].length;
    D.18814 = D.18813 * 2;
    D.18815 = (unsigned int) D.18814;
    D.18812 = D.18815 + 26;
    return D.18812;
    <D.18811>:
    D.18812 = (guint) size;
    return D.18812;
  }
  <D.18809>:
  if (type == 4) goto <D.18816>; else goto <D.18817>;
  <D.18816>:
  {
    int element_size;
    struct MonoArray * array;
    size_t size;

    D.18818 = descr >> 3;
    D.18819 = (int) D.18818;
    element_size = D.18819 & 1023;
    array = o;
    D.18820 = array->max_length;
    element_size.16 = (unsigned int) element_size;
    D.18822 = D.18820 * element_size.16;
    D.18823 = (long unsigned int) D.18822;
    size = D.18823 + 32;
    D.18824 = descr & 8192;
    if (D.18824 != 0) goto <D.18825>; else goto <D.18826>;
    <D.18825>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.18827 = vtable->klass;
    D.18828 = D.18827->rank;
    D.18829 = (long unsigned int) D.18828;
    D.18830 = D.18829 * 8;
    size = D.18830 + size;
    <D.18826>:
    D.18812 = (guint) size;
    return D.18812;
  }
  <D.18817>:
  D.18812 = slow_object_get_size (vtable, o);
  return D.18812;
}


slow_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  struct MonoClass * D.18832;
  guint D.18835;
  int D.18836;
  int D.18837;
  unsigned int D.18838;
  unsigned char D.18839;
  int D.18842;
  unsigned int D.18843;
  unsigned int D.18844;
  unsigned int D.18845;
  long unsigned int D.18846;
  struct MonoArrayBounds * D.18847;
  _Bool D.18848;
  long int D.18849;
  long int D.18850;
  long unsigned int D.18853;
  long unsigned int D.18854;
  int D.18855;
  struct MonoClass * klass;

  klass = vtable->klass;
  D.18832 = mono_defaults.string_class;
  if (D.18832 == klass) goto <D.18833>; else goto <D.18834>;
  <D.18833>:
  D.18836 = MEM[(struct MonoString *)o].length;
  D.18837 = D.18836 * 2;
  D.18838 = (unsigned int) D.18837;
  D.18835 = D.18838 + 26;
  return D.18835;
  <D.18834>:
  D.18839 = klass->rank;
  if (D.18839 != 0) goto <D.18840>; else goto <D.18841>;
  <D.18840>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.18842 = klass->sizes.element_size;
    D.18843 = (unsigned int) D.18842;
    D.18844 = array->max_length;
    D.18845 = D.18843 * D.18844;
    D.18846 = (long unsigned int) D.18845;
    size = D.18846 + 32;
    D.18847 = array->bounds;
    D.18848 = D.18847 != 0B;
    D.18849 = (long int) D.18848;
    D.18850 = __builtin_expect (D.18849, 0);
    if (D.18850 != 0) goto <D.18851>; else goto <D.18852>;
    <D.18851>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.18839 = klass->rank;
    D.18853 = (long unsigned int) D.18839;
    D.18854 = D.18853 * 8;
    size = D.18854 + size;
    <D.18852>:
    D.18835 = (guint) size;
    return D.18835;
  }
  <D.18841>:
  D.18855 = klass->instance_size;
  D.18835 = (guint) D.18855;
  return D.18835;
}


alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int promote_age.17;
  char * D.18860;
  void * (*<T2e87>) (struct MonoVTable *, int, gboolean) D.18861;
  int D.18862;
  char * D.18863;
  char * D.18864;
  _Bool D.18865;
  long int D.18866;
  long int D.18867;
  char * D.18870;
  char * D.18871;
  char * p;
  int age;

  p = 0B;
  age = get_object_age (obj);
  promote_age.17 = promote_age;
  if (age >= promote_age.17) goto <D.18858>; else goto <D.18859>;
  <D.18858>:
  D.18861 = major_collector.alloc_object;
  D.18862 = (int) objsize;
  D.18860 = D.18861 (vtable, D.18862, has_references);
  return D.18860;
  <D.18859>:
  age = age + 1;
  p = age_alloc_buffers[age].next;
  D.18863 = p + objsize;
  D.18864 = age_alloc_buffers[age].end;
  D.18865 = D.18863 <= D.18864;
  D.18866 = (long int) D.18865;
  D.18867 = __builtin_expect (D.18866, 1);
  if (D.18867 != 0) goto <D.18868>; else goto <D.18869>;
  <D.18868>:
  D.18870 = age_alloc_buffers[age].next;
  D.18871 = D.18870 + objsize;
  age_alloc_buffers[age].next = D.18871;
  goto <D.18872>;
  <D.18869>:
  p = alloc_for_promotion_slow_path (age, objsize);
  if (p == 0B) goto <D.18873>; else goto <D.18874>;
  <D.18873>:
  D.18861 = major_collector.alloc_object;
  D.18862 = (int) objsize;
  D.18860 = D.18861 (vtable, D.18862, has_references);
  return D.18860;
  <D.18874>:
  <D.18872>:
  MEM[(struct MonoVTable * *)p] = vtable;
  D.18860 = p;
  return D.18860;
}


get_object_age (char * object)
{
  long int object.18;
  char * sgen_nursery_start.19;
  long int sgen_nursery_start.20;
  long int D.18879;
  long int D.18880;
  int D.18881;
  char * region_age.21;
  sizetype D.18883;
  char * D.18884;
  char D.18885;
  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.18879 = object.18 - sgen_nursery_start.20;
  D.18880 = D.18879 >> 9;
  idx = (int) D.18880;
  region_age.21 = region_age;
  D.18883 = (sizetype) idx;
  D.18884 = region_age.21 + D.18883;
  D.18885 = *D.18884;
  D.18881 = (int) D.18885;
  return D.18881;
}


alloc_for_promotion_slow_path (int age, size_t objsize)
{
  long unsigned int D.18887;
  long unsigned int D.18888;
  long unsigned int D.18889;
  long unsigned int allocated_size.22;
  char * D.18893;
  char * D.18894;
  char * D.18895;
  char * D.18896;
  char * D.18897;
  char * p;
  size_t allocated_size;
  size_t aligned_objsize;

  try
    {
      D.18887 = objsize + 511;
      aligned_objsize = D.18887 & 18446744073709551104;
      D.18888 = MAX_EXPR <aligned_objsize, 512>;
      D.18889 = MAX_EXPR <aligned_objsize, 4096>;
      p = sgen_fragment_allocator_serial_range_alloc (&collector_allocator, D.18889, D.18888, &allocated_size);
      if (p != 0B) goto <D.18890>; else goto <D.18891>;
      <D.18890>:
      allocated_size.22 = allocated_size;
      D.18893 = p + allocated_size.22;
      set_age_in_range (p, D.18893, age);
      D.18894 = age_alloc_buffers[age].end;
      D.18895 = age_alloc_buffers[age].next;
      sgen_clear_range (D.18895, D.18894);
      D.18896 = p + objsize;
      age_alloc_buffers[age].next = D.18896;
      allocated_size.22 = allocated_size;
      D.18893 = p + allocated_size.22;
      age_alloc_buffers[age].end = D.18893;
      <D.18891>:
      D.18897 = p;
      return D.18897;
    }
  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.18903;
  long int D.18904;
  char * region_age.26;
  sizetype D.18906;
  long int end.27;
  long int D.18908;
  long int D.18909;
  long unsigned int D.18910;
  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.18903 = start.23 - sgen_nursery_start.25;
  D.18904 = D.18903 >> 9;
  region_idx = (int) D.18904;
  region_age.26 = region_age;
  D.18906 = (sizetype) region_idx;
  region_start = region_age.26 + D.18906;
  end.27 = (long int) end;
  start.23 = (long int) start;
  D.18908 = end.27 - start.23;
  D.18909 = D.18908 >> 9;
  length = (int) D.18909;
  D.18910 = (long unsigned int) length;
  memset (region_start, age, D.18910);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.18913;
  int D.18918;
  void * D.18920;
  long unsigned int D.18921;

  D.18913 = __builtin_constant_p (__len);
  if (D.18913 != 0) goto <D.18914>; else goto <D.18915>;
  <D.18914>:
  if (__len == 0) goto <D.18916>; else goto <D.18917>;
  <D.18916>:
  D.18918 = __builtin_constant_p (__ch);
  if (D.18918 == 0) goto <D.18911>; else goto <D.18919>;
  <D.18919>:
  if (__ch != 0) goto <D.18911>; else goto <D.18912>;
  <D.18911>:
  __warn_memset_zero_len ();
  D.18920 = __dest;
  return D.18920;
  <D.18912>:
  <D.18917>:
  <D.18915>:
  D.18921 = __builtin_object_size (__dest, 0);
  D.18920 = __builtin___memset_chk (__dest, __ch, __len, D.18921);
  return D.18920;
}


par_copy_object_no_checks (char * destination, struct MonoVTable * vt, void * obj, mword objsize, struct SgenGrayQueue * queue)
{
  struct MonoClass * D.18925;
  const char * D.18926;
  const char * D.18927;
  struct MonoVTable * D.18930;
  struct MonoClass * D.18931;
  const char * D.18932;
  struct FILE * gc_debug_file.28;
  long unsigned int D.18936;
  const void * D.18937;
  mword * D.18938;
  long unsigned int D.18939;
  mword * D.18940;
  long unsigned int D.18941;
  mword * D.18942;
  long unsigned int D.18943;
  mword * D.18944;
  long unsigned int D.18945;
  mword * D.18946;
  long unsigned int D.18947;
  mword * D.18948;
  long unsigned int D.18949;
  mword * D.18950;
  long unsigned int D.18951;
  long unsigned int D.18953;
  const void * D.18954;
  void * D.18955;
  int iftmp.29;
  unsigned char D.18961;
  struct MonoArrayBounds * D.18963;
  _Bool D.18965;
  long int D.18966;
  long int D.18967;
  long int D.18970;
  long int obj.30;
  long int D.18972;
  sizetype D.18973;
  struct MonoArrayBounds * D.18974;
  long unsigned int D.18977;
  int D.18978;
  <unnamed type> mono_profiler_events.31;
  unsigned int D.18980;
  _Bool D.18981;
  long int D.18982;
  long int D.18983;
  const char * D.18990;
  int iftmp.32;
  struct GrayQueueSection * D.18995;
  int D.18997;
  _Bool D.18998;
  long int D.18999;
  long int D.19000;
  int D.19004;
  int D.19005;
  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.18923>; else goto <D.18924>;
  <D.18923>:
  D.18925 = vt->klass;
  D.18926 = D.18925->name;
  D.18925 = vt->klass;
  D.18927 = D.18925->name_space;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s was not initialized", vt, D.18927, D.18926);
  <D.18117>:
  goto <D.18117>;
  <D.18924>:
  if (0 != 0) goto <D.18928>; else goto <D.18929>;
  <D.18928>:
  D.18930 = MEM[(struct MonoObject *)obj].vtable;
  D.18931 = D.18930->klass;
  D.18932 = D.18931->name;
  gc_debug_file.28 = gc_debug_file;
  fprintf (gc_debug_file.28, " (to %p, %s size: %lu)\n", destination, D.18932, objsize);
  gc_debug_file.28 = gc_debug_file;
  fflush (gc_debug_file.28);
  <D.18929>:
  if (objsize <= 64) goto <D.18934>; else goto <D.18935>;
  <D.18934>:
  {
    mword * dest;

    dest = destination;
    D.18936 = objsize / 8;
    D.18937 = copy_labels[D.18936];
    goto D.18937;
    LAB_8:
    D.18938 = dest + 56;
    D.18939 = MEM[(mword *)obj + 56B];
    *D.18938 = D.18939;
    LAB_7:
    D.18940 = dest + 48;
    D.18941 = MEM[(mword *)obj + 48B];
    *D.18940 = D.18941;
    LAB_6:
    D.18942 = dest + 40;
    D.18943 = MEM[(mword *)obj + 40B];
    *D.18942 = D.18943;
    LAB_5:
    D.18944 = dest + 32;
    D.18945 = MEM[(mword *)obj + 32B];
    *D.18944 = D.18945;
    LAB_4:
    D.18946 = dest + 24;
    D.18947 = MEM[(mword *)obj + 24B];
    *D.18946 = D.18947;
    LAB_3:
    D.18948 = dest + 16;
    D.18949 = MEM[(mword *)obj + 16B];
    *D.18948 = D.18949;
    LAB_2:
    D.18950 = dest + 8;
    D.18951 = MEM[(mword *)obj + 8B];
    *D.18950 = D.18951;
    LAB_1:
    LAB_0:
  }
  goto <D.18952>;
  <D.18935>:
  D.18953 = objsize + 18446744073709551608;
  D.18954 = obj + 8;
  D.18955 = destination + 8;
  mono_gc_memmove_aligned (D.18955, D.18954, D.18953);
  <D.18952>:
  if (0 != 0) goto <D.18956>; else goto <D.18957>;
  <D.18956>:
  D.18925 = vt->klass;
  D.18926 = D.18925->name;
  D.18925 = vt->klass;
  D.18927 = D.18925->name_space;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s has no gc descriptor", vt, D.18927, D.18926);
  <D.18119>:
  goto <D.18119>;
  <D.18957>:
  D.18961 = vt->rank;
  if (D.18961 != 0) goto <D.18962>; else goto <D.18959>;
  <D.18962>:
  D.18963 = MEM[(struct MonoArray *)obj].bounds;
  if (D.18963 != 0B) goto <D.18964>; else goto <D.18959>;
  <D.18964>:
  iftmp.29 = 1;
  goto <D.18960>;
  <D.18959>:
  iftmp.29 = 0;
  <D.18960>:
  D.18965 = iftmp.29 != 0;
  D.18966 = (long int) D.18965;
  D.18967 = __builtin_expect (D.18966, 0);
  if (D.18967 != 0) goto <D.18968>; else goto <D.18969>;
  <D.18968>:
  {
    struct MonoArray * array;

    array = destination;
    D.18963 = MEM[(struct MonoArray *)obj].bounds;
    D.18970 = (long int) D.18963;
    obj.30 = (long int) obj;
    D.18972 = D.18970 - obj.30;
    D.18973 = (sizetype) D.18972;
    D.18974 = destination + D.18973;
    array->bounds = D.18974;
    if (0 != 0) goto <D.18975>; else goto <D.18976>;
    <D.18975>:
    D.18977 = mono_array_length (array);
    D.18961 = vt->rank;
    D.18978 = (int) D.18961;
    gc_debug_file.28 = gc_debug_file;
    fprintf (gc_debug_file.28, "Array instance %p: size: %lu, rank: %d, length: %lu\n", array, objsize, D.18978, D.18977);
    gc_debug_file.28 = gc_debug_file;
    fflush (gc_debug_file.28);
    <D.18976>:
  }
  <D.18969>:
  mono_profiler_events.31 = mono_profiler_events;
  D.18980 = mono_profiler_events.31 & 524288;
  D.18981 = D.18980 != 0;
  D.18982 = (long int) D.18981;
  D.18983 = __builtin_expect (D.18982, 0);
  if (D.18983 != 0) goto <D.18984>; else goto <D.18985>;
  <D.18984>:
  sgen_register_moved_object (obj, destination);
  <D.18985>:
  obj = destination;
  if (queue != 0B) goto <D.18986>; else goto <D.18987>;
  <D.18986>:
  if (0 != 0) goto <D.18988>; else goto <D.18989>;
  <D.18988>:
  D.18990 = sgen_safe_name (obj);
  gc_debug_file.28 = gc_debug_file;
  fprintf (gc_debug_file.28, "Enqueuing gray object %p (%s)\n", obj, D.18990);
  gc_debug_file.28 = gc_debug_file;
  fflush (gc_debug_file.28);
  <D.18989>:
  D.18995 = queue->first;
  if (D.18995 == 0B) goto <D.18992>; else goto <D.18996>;
  <D.18996>:
  D.18995 = queue->first;
  D.18997 = D.18995->end;
  if (D.18997 == 125) goto <D.18992>; else goto <D.18993>;
  <D.18992>:
  iftmp.32 = 1;
  goto <D.18994>;
  <D.18993>:
  iftmp.32 = 0;
  <D.18994>:
  D.18998 = iftmp.32 != 0;
  D.18999 = (long int) D.18998;
  D.19000 = __builtin_expect (D.18999, 0);
  if (D.19000 != 0) goto <D.19001>; else goto <D.19002>;
  <D.19001>:
  sgen_gray_object_enqueue (queue, obj);
  goto <D.19003>;
  <D.19002>:
  D.18995 = queue->first;
  D.18995 = queue->first;
  D.18997 = D.18995->end;
  D.19004 = D.18997;
  D.19005 = D.19004 + 1;
  D.18995->end = D.19005;
  D.18995->objects[D.19004] = obj;
  <D.19003>:
  __builtin_prefetch (obj);
  <D.18987>:
}


sgen_ptr_in_nursery (void * p)
{
  gboolean D.19008;
  int sgen_nursery_bits.34;
  int D.19010;
  int D.19011;
  long unsigned int D.19012;
  long unsigned int p.35;
  long unsigned int D.19014;
  char * sgen_nursery_start.36;
  long unsigned int sgen_nursery_start.37;
  _Bool D.19017;

  sgen_nursery_bits.34 = sgen_nursery_bits;
  D.19010 = 1 << sgen_nursery_bits.34;
  D.19011 = -D.19010;
  D.19012 = (long unsigned int) D.19011;
  p.35 = (long unsigned int) p;
  D.19014 = D.19012 & p.35;
  sgen_nursery_start.36 = sgen_nursery_start;
  sgen_nursery_start.37 = (long unsigned int) sgen_nursery_start.36;
  D.19017 = D.19014 == sgen_nursery_start.37;
  D.19008 = (gboolean) D.19017;
  return D.19008;
}


split_nursery_serial_scan_object (char * start, struct SgenGrayQueue * queue)
{
  long unsigned int D.19019;
  long unsigned int D.19020;
  long unsigned int D.19021;
  long unsigned int D.19022;
  long unsigned int D.19025;
  long unsigned int D.19026;
  long unsigned int D.19027;
  long unsigned int D.19028;
  long unsigned int D.19029;
  long unsigned int D.19030;
  void * D.19035;
  struct FILE * gc_debug_file.38;
  long unsigned int D.19045;
  long unsigned int D.19046;
  int D.19047;
  void * D.19052;
  long unsigned int D.19055;
  long unsigned int D.19056;
  int D.19057;
  long unsigned int D.19064;
  long unsigned int D.19067;
  int D.19068;
  int D.19069;
  unsigned int D.19072;
  unsigned int el_size.39;
  unsigned int D.19074;
  sizetype D.19075;
  void * D.19080;
  int D.19086;
  int D.19087;
  long unsigned int D.19088;
  long unsigned int D.19089;
  long unsigned int D.19090;
  long unsigned int D.19091;
  void * * D.19092;
  void * D.19097;
  sizetype D.19100;
  long unsigned int D.19104;
  void * D.19111;
  long unsigned int D.19114;
  void * D.19121;
  long unsigned int D.19124;
  unsigned int D.19125;
  unsigned int D.19126;
  struct MonoVTable * D.19129;
  struct MonoClass * D.19130;
  const char * D.19131;
  const char * D.19132;
  gsize * bitmap_data.40;
  long unsigned int D.19134;
  void * D.19141;
  int bwords.41;
  long unsigned int D.19145;
  gsize * mbitmap_data.42;
  long unsigned int D.19147;
  unsigned int D.19148;
  unsigned int D.19149;
  struct MonoClass * D.19150;
  unsigned int el_size.43;
  unsigned int D.19152;
  sizetype D.19153;
  const char * D.19156;
  const char * D.19157;
  gsize * bitmap_data.44;
  long unsigned int D.19159;
  void * D.19166;
  unsigned int bwords.45;
  sizetype D.19170;

  {
    struct GCVTable * vt;
    mword desc;

    D.19019 = MEM[(mword *)start];
    D.19020 = D.19019 & 18446744073709551612;
    vt = (struct GCVTable *) D.19020;
    desc = vt->desc;
    D.19021 = desc & 7;
    switch (D.19021) <default: <D.18464>, case 1: <D.18369>, case 2: <D.18378>, case 3: <D.18428>, case 4: <D.18388>, case 5: <D.18421>, case 6: <D.18442>, case 7: <D.18463>>
    <D.18369>:
    D.19022 = desc & 4294901760;
    if (D.19022 != 0) goto <D.19023>; else goto <D.19024>;
    <D.19023>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19025 = desc >> 16;
      D.19026 = D.19025 & 255;
      D.19027 = D.19026 * 8;
      _objptr = _objptr + D.19027;
      D.19028 = desc >> 24;
      D.19029 = D.19028 & 255;
      D.19030 = D.19029 * 8;
      _objptr_end = _objptr + D.19030;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19031>; else goto <D.19032>;
        <D.19031>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19033>; else goto <D.19034>;
        <D.19033>:
        D.19035 = *_objptr;
        if (D.19035 != __old) goto <D.19036>; else goto <D.19037>;
        <D.19036>:
        D.19035 = *_objptr;
        gc_debug_file.38 = gc_debug_file;
        fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19035, __old);
        gc_debug_file.38 = gc_debug_file;
        fflush (gc_debug_file.38);
        <D.19037>:
        <D.19034>:
        <D.19032>:
      }
      _objptr = _objptr + 8;
      goto <D.18375>;
      <D.18374>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19039>; else goto <D.19040>;
        <D.19039>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19041>; else goto <D.19042>;
        <D.19041>:
        D.19035 = *_objptr;
        if (D.19035 != __old) goto <D.19043>; else goto <D.19044>;
        <D.19043>:
        D.19035 = *_objptr;
        gc_debug_file.38 = gc_debug_file;
        fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19035, __old);
        gc_debug_file.38 = gc_debug_file;
        fflush (gc_debug_file.38);
        <D.19044>:
        <D.19042>:
        <D.19040>:
      }
      _objptr = _objptr + 8;
      <D.18375>:
      if (_objptr < _objptr_end) goto <D.18374>; else goto <D.18376>;
      <D.18376>:
    }
    <D.19024>:
    goto <D.18377>;
    <D.18378>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.19045 = (long unsigned int) _index;
        D.19046 = D.19045 * 8;
        _objptr = _objptr + D.19046;
        D.19047 = _index + 1;
        _bmap = _bmap >> D.19047;
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.19048>; else goto <D.19049>;
          <D.19048>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.19050>; else goto <D.19051>;
          <D.19050>:
          D.19052 = *_objptr;
          if (D.19052 != __old) goto <D.19053>; else goto <D.19054>;
          <D.19053>:
          D.19052 = *_objptr;
          gc_debug_file.38 = gc_debug_file;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19052, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19054>:
          <D.19051>:
          <D.19049>:
        }
        _objptr = _objptr + 8;
      }
      goto <D.18386>;
      <D.18385>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.19055 = (long unsigned int) _index;
        D.19056 = D.19055 * 8;
        _objptr = _objptr + D.19056;
        D.19057 = _index + 1;
        _bmap = _bmap >> D.19057;
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.19058>; else goto <D.19059>;
          <D.19058>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.19060>; else goto <D.19061>;
          <D.19060>:
          D.19052 = *_objptr;
          if (D.19052 != __old) goto <D.19062>; else goto <D.19063>;
          <D.19062>:
          D.19052 = *_objptr;
          gc_debug_file.38 = gc_debug_file;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19052, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19063>:
          <D.19061>:
          <D.19059>:
        }
        _objptr = _objptr + 8;
      }
      <D.18386>:
      if (_bmap != 0) goto <D.18385>; else goto <D.18387>;
      <D.18387>:
    }
    goto <D.18377>;
    <D.18388>:
    D.19064 = desc & 4294950912;
    if (D.19064 != 0) goto <D.19065>; else goto <D.19066>;
    <D.19065>:
    {
      int el_size;
      int etype;

      D.19067 = desc >> 3;
      D.19068 = (int) D.19067;
      el_size = D.19068 & 1023;
      D.19069 = (int) desc;
      etype = D.19069 & 49152;
      if (etype == 16384) goto <D.19070>; else goto <D.19071>;
      <D.19070>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.19072 = MEM[(struct MonoArray *)start].max_length;
        el_size.39 = (unsigned int) el_size;
        D.19074 = D.19072 * el_size.39;
        D.19075 = (sizetype) D.19074;
        end_refs = p + D.19075;
        goto <D.18395>;
        <D.18394>:
        {
          void * __old;

          __old = *p;
          if (__old != 0B) goto <D.19076>; else goto <D.19077>;
          <D.19076>:
          split_nursery_serial_copy_object_from_obj (p, queue);
          if (0 != 0) goto <D.19078>; else goto <D.19079>;
          <D.19078>:
          D.19080 = *p;
          if (D.19080 != __old) goto <D.19081>; else goto <D.19082>;
          <D.19081>:
          D.19080 = *p;
          gc_debug_file.38 = gc_debug_file;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", p, D.19080, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19082>:
          <D.19079>:
          <D.19077>:
        }
        p = p + 8;
        <D.18395>:
        if (p < end_refs) goto <D.18394>; else goto <D.18396>;
        <D.18396>:
      }
      goto <D.19083>;
      <D.19071>:
      if (etype == 32768) goto <D.19084>; else goto <D.19085>;
      <D.19084>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19025 = desc >> 16;
        D.19086 = (int) D.19025;
        offset = D.19086 & 255;
        D.19028 = desc >> 24;
        D.19087 = (int) D.19028;
        num_refs = D.19087 & 255;
        e_start = start + 32;
        D.19072 = MEM[(struct MonoArray *)start].max_length;
        el_size.39 = (unsigned int) el_size;
        D.19074 = D.19072 * el_size.39;
        D.19075 = (sizetype) D.19074;
        e_end = e_start + D.19075;
        goto <D.18408>;
        <D.18407>:
        {
          void * * p;
          int i;

          p = e_start;
          D.19088 = (long unsigned int) offset;
          D.19089 = D.19088 * 8;
          p = p + D.19089;
          i = 0;
          goto <D.18405>;
          <D.18404>:
          {
            void * __old;

            D.19090 = (long unsigned int) i;
            D.19091 = D.19090 * 8;
            D.19092 = p + D.19091;
            __old = *D.19092;
            if (__old != 0B) goto <D.19093>; else goto <D.19094>;
            <D.19093>:
            D.19090 = (long unsigned int) i;
            D.19091 = D.19090 * 8;
            D.19092 = p + D.19091;
            split_nursery_serial_copy_object_from_obj (D.19092, queue);
            if (0 != 0) goto <D.19095>; else goto <D.19096>;
            <D.19095>:
            D.19090 = (long unsigned int) i;
            D.19091 = D.19090 * 8;
            D.19092 = p + D.19091;
            D.19097 = *D.19092;
            if (D.19097 != __old) goto <D.19098>; else goto <D.19099>;
            <D.19098>:
            D.19090 = (long unsigned int) i;
            D.19091 = D.19090 * 8;
            D.19092 = p + D.19091;
            D.19097 = *D.19092;
            D.19090 = (long unsigned int) i;
            D.19091 = D.19090 * 8;
            D.19092 = p + D.19091;
            gc_debug_file.38 = gc_debug_file;
            fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", D.19092, D.19097, __old);
            gc_debug_file.38 = gc_debug_file;
            fflush (gc_debug_file.38);
            <D.19099>:
            <D.19096>:
            <D.19094>:
          }
          i = i + 1;
          <D.18405>:
          if (i < num_refs) goto <D.18404>; else goto <D.18406>;
          <D.18406>:
          D.19100 = (sizetype) el_size;
          e_start = e_start + D.19100;
        }
        <D.18408>:
        if (e_start < e_end) goto <D.18407>; else goto <D.18409>;
        <D.18409>:
      }
      goto <D.19101>;
      <D.19085>:
      if (etype == 49152) goto <D.19102>; else goto <D.19103>;
      <D.19102>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.19072 = MEM[(struct MonoArray *)start].max_length;
        el_size.39 = (unsigned int) el_size;
        D.19074 = D.19072 * el_size.39;
        D.19075 = (sizetype) D.19074;
        e_end = e_start + D.19075;
        goto <D.18419>;
        <D.18418>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.18416>;
          <D.18415>:
          D.19104 = _bmap & 1;
          if (D.19104 != 0) goto <D.19105>; else goto <D.19106>;
          <D.19105>:
          {
            void * __old;

            __old = *p;
            if (__old != 0B) goto <D.19107>; else goto <D.19108>;
            <D.19107>:
            split_nursery_serial_copy_object_from_obj (p, queue);
            if (0 != 0) goto <D.19109>; else goto <D.19110>;
            <D.19109>:
            D.19111 = *p;
            if (D.19111 != __old) goto <D.19112>; else goto <D.19113>;
            <D.19112>:
            D.19111 = *p;
            gc_debug_file.38 = gc_debug_file;
            fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", p, D.19111, __old);
            gc_debug_file.38 = gc_debug_file;
            fflush (gc_debug_file.38);
            <D.19113>:
            <D.19110>:
            <D.19108>:
          }
          <D.19106>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.18416>:
          if (_bmap != 0) goto <D.18415>; else goto <D.18417>;
          <D.18417>:
          D.19100 = (sizetype) el_size;
          e_start = e_start + D.19100;
        }
        <D.18419>:
        if (e_start < e_end) goto <D.18418>; else goto <D.18420>;
        <D.18420>:
      }
      <D.19103>:
      <D.19101>:
      <D.19083>:
    }
    <D.19066>:
    goto <D.18377>;
    <D.18421>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.18426>;
      <D.18425>:
      D.19114 = _bmap & 1;
      if (D.19114 != 0) goto <D.19115>; else goto <D.19116>;
      <D.19115>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.19117>; else goto <D.19118>;
        <D.19117>:
        split_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.19119>; else goto <D.19120>;
        <D.19119>:
        D.19121 = *_objptr;
        if (D.19121 != __old) goto <D.19122>; else goto <D.19123>;
        <D.19122>:
        D.19121 = *_objptr;
        gc_debug_file.38 = gc_debug_file;
        fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19121, __old);
        gc_debug_file.38 = gc_debug_file;
        fflush (gc_debug_file.38);
        <D.19123>:
        <D.19120>:
        <D.19118>:
      }
      <D.19116>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18426>:
      if (_bmap != 0) goto <D.18425>; else goto <D.18427>;
      <D.18427>:
    }
    goto <D.18377>;
    <D.18428>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19124 = *bitmap_data;
      D.19125 = (unsigned int) D.19124;
      D.19126 = D.19125 + 4294967295;
      bwords = (int) D.19126;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.19127>; else goto <D.19128>;
      <D.19127>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19129 = myobj->vtable;
        D.19130 = D.19129->klass;
        D.19131 = D.19130->name;
        D.19129 = myobj->vtable;
        D.19130 = D.19129->klass;
        D.19132 = D.19130->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19132, D.19131);
      }
      <D.19128>:
      goto <D.18440>;
      <D.18439>:
      {
        gsize _bmap;

        bitmap_data.40 = bitmap_data;
        bitmap_data = bitmap_data.40 + 8;
        _bmap = *bitmap_data.40;
        _objptr = start_run;
        goto <D.18437>;
        <D.18436>:
        D.19134 = _bmap & 1;
        if (D.19134 != 0) goto <D.19135>; else goto <D.19136>;
        <D.19135>:
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.19137>; else goto <D.19138>;
          <D.19137>:
          split_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.19139>; else goto <D.19140>;
          <D.19139>:
          D.19141 = *_objptr;
          if (D.19141 != __old) goto <D.19142>; else goto <D.19143>;
          <D.19142>:
          D.19141 = *_objptr;
          gc_debug_file.38 = gc_debug_file;
          fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19141, __old);
          gc_debug_file.38 = gc_debug_file;
          fflush (gc_debug_file.38);
          <D.19143>:
          <D.19140>:
          <D.19138>:
        }
        <D.19136>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18437>:
        if (_bmap != 0) goto <D.18436>; else goto <D.18438>;
        <D.18438>:
        start_run = start_run + 512;
      }
      <D.18440>:
      bwords.41 = bwords;
      bwords = bwords.41 + -1;
      if (bwords.41 > 0) goto <D.18439>; else goto <D.18441>;
      <D.18441>:
    }
    goto <D.18377>;
    <D.18442>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19145 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19145);
      mbitmap_data.42 = mbitmap_data;
      mbitmap_data = mbitmap_data.42 + 8;
      D.19147 = *mbitmap_data.42;
      D.19148 = (unsigned int) D.19147;
      D.19149 = D.19148 + 4294967295;
      mbwords = (int) D.19149;
      D.19150 = vt->klass;
      el_size = mono_array_element_size (D.19150);
      e_start = start + 32;
      D.19072 = MEM[(struct MonoArray *)start].max_length;
      el_size.43 = (unsigned int) el_size;
      D.19152 = D.19072 * el_size.43;
      D.19153 = (sizetype) D.19152;
      e_end = e_start + D.19153;
      if (0 != 0) goto <D.19154>; else goto <D.19155>;
      <D.19154>:
      D.19150 = vt->klass;
      D.19156 = D.19150->name;
      D.19150 = vt->klass;
      D.19157 = D.19150->name_space;
      D.19145 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19145, D.19157, D.19156);
      <D.19155>:
      goto <D.18461>;
      <D.18460>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.18458>;
        <D.18457>:
        {
          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.18455>;
          <D.18454>:
          D.19159 = _bmap & 1;
          if (D.19159 != 0) goto <D.19160>; else goto <D.19161>;
          <D.19160>:
          {
            void * __old;

            __old = *_objptr;
            if (__old != 0B) goto <D.19162>; else goto <D.19163>;
            <D.19162>:
            split_nursery_serial_copy_object_from_obj (_objptr, queue);
            if (0 != 0) goto <D.19164>; else goto <D.19165>;
            <D.19164>:
            D.19166 = *_objptr;
            if (D.19166 != __old) goto <D.19167>; else goto <D.19168>;
            <D.19167>:
            D.19166 = *_objptr;
            gc_debug_file.38 = gc_debug_file;
            fprintf (gc_debug_file.38, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19166, __old);
            gc_debug_file.38 = gc_debug_file;
            fflush (gc_debug_file.38);
            <D.19168>:
            <D.19165>:
            <D.19163>:
          }
          <D.19161>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18455>:
          if (_bmap != 0) goto <D.18454>; else goto <D.18456>;
          <D.18456>:
          _objptr = start_run + 512;
        }
        <D.18458>:
        bwords.45 = bwords;
        bwords = bwords.45 + 4294967295;
        if (bwords.45 != 0) goto <D.18457>; else goto <D.18459>;
        <D.18459>:
        D.19170 = (sizetype) el_size;
        e_start = e_start + D.19170;
      }
      <D.18461>:
      if (e_start < e_end) goto <D.18460>; else goto <D.18462>;
      <D.18462>:
    }
    goto <D.18377>;
    <D.18463>:
    goto <D.18377>;
    <D.18464>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.18377>:
  }
}


split_nursery_parallel_scan_vtype (char * start, mword desc, struct SgenGrayQueue * queue)
{
  long unsigned int D.19172;
  long unsigned int D.19173;
  long unsigned int D.19176;
  long unsigned int D.19177;
  long unsigned int D.19178;
  long unsigned int D.19179;
  long unsigned int D.19180;
  long unsigned int D.19181;
  void * D.19188;
  struct FILE * gc_debug_file.46;
  int iftmp.47;
  int D.19193;
  int D.19195;
  _Bool D.19197;
  long int D.19198;
  long int D.19199;
  int iftmp.48;
  int D.19211;
  int D.19213;
  _Bool D.19215;
  long int D.19216;
  long int D.19217;
  long unsigned int D.19220;
  long unsigned int D.19221;
  int D.19222;
  void * D.19229;
  int iftmp.49;
  int D.19233;
  int D.19235;
  _Bool D.19237;
  long int D.19238;
  long int D.19239;
  long unsigned int D.19242;
  long unsigned int D.19243;
  int D.19244;
  int iftmp.50;
  int D.19254;
  int D.19256;
  _Bool D.19258;
  long int D.19259;
  long int D.19260;
  long unsigned int D.19263;
  long unsigned int D.19266;
  int D.19267;
  int D.19268;
  unsigned int D.19271;
  unsigned int el_size.51;
  unsigned int D.19273;
  sizetype D.19274;
  void * D.19281;
  int iftmp.52;
  int D.19285;
  int D.19287;
  _Bool D.19289;
  long int D.19290;
  long int D.19291;
  int D.19297;
  int D.19298;
  long unsigned int D.19299;
  long unsigned int D.19300;
  long unsigned int D.19301;
  long unsigned int D.19302;
  void * * D.19303;
  void * D.19310;
  int iftmp.53;
  int D.19314;
  void * D.19316;
  int D.19317;
  _Bool D.19319;
  long int D.19320;
  long int D.19321;
  void * D.19324;
  sizetype D.19325;
  long unsigned int D.19329;
  void * D.19338;
  int iftmp.54;
  int D.19342;
  int D.19344;
  _Bool D.19346;
  long int D.19347;
  long int D.19348;
  long unsigned int D.19351;
  void * D.19360;
  int iftmp.55;
  int D.19364;
  int D.19366;
  _Bool D.19368;
  long int D.19369;
  long int D.19370;
  long unsigned int D.19373;
  unsigned int D.19374;
  unsigned int D.19375;
  struct MonoVTable * D.19378;
  struct MonoClass * D.19379;
  const char * D.19380;
  const char * D.19381;
  gsize * bitmap_data.56;
  long unsigned int D.19383;
  void * D.19392;
  int iftmp.57;
  int D.19396;
  int D.19398;
  _Bool D.19400;
  long int D.19401;
  long int D.19402;
  int bwords.58;

  start = start + 18446744073709551600;
  D.19172 = desc & 7;
  switch (D.19172) <default: <D.18362>, case 1: <D.18279>, case 2: <D.18290>, case 3: <D.18346>, case 4: <D.18302>, case 5: <D.18338>, case 7: <D.18361>>
  <D.18279>:
  D.19173 = desc & 4294901760;
  if (D.19173 != 0) goto <D.19174>; else goto <D.19175>;
  <D.19174>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.19176 = desc >> 16;
    D.19177 = D.19176 & 255;
    D.19178 = D.19177 * 8;
    _objptr = _objptr + D.19178;
    D.19179 = desc >> 24;
    D.19180 = D.19179 & 255;
    D.19181 = D.19180 * 8;
    _objptr_end = _objptr + D.19181;
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.19182>; else goto <D.19183>;
      <D.19182>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.19184>; else goto <D.19185>;
      <D.19184>:
      if (__old != __copy) goto <D.19186>; else goto <D.19187>;
      <D.19186>:
      D.19188 = *_objptr;
      gc_debug_file.46 = gc_debug_file;
      fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19188, __old);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19187>:
      <D.19185>:
      D.19193 = sgen_ptr_in_nursery (__copy);
      if (D.19193 != 0) goto <D.19194>; else goto <D.19191>;
      <D.19194>:
      D.19195 = sgen_ptr_in_nursery (_objptr);
      if (D.19195 == 0) goto <D.19196>; else goto <D.19191>;
      <D.19196>:
      iftmp.47 = 1;
      goto <D.19192>;
      <D.19191>:
      iftmp.47 = 0;
      <D.19192>:
      D.19197 = iftmp.47 != 0;
      D.19198 = (long int) D.19197;
      D.19199 = __builtin_expect (D.19198, 0);
      if (D.19199 != 0) goto <D.19200>; else goto <D.19201>;
      <D.19200>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.19201>:
      <D.19183>:
    }
    _objptr = _objptr + 8;
    goto <D.18287>;
    <D.18286>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.19202>; else goto <D.19203>;
      <D.19202>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.19204>; else goto <D.19205>;
      <D.19204>:
      if (__old != __copy) goto <D.19206>; else goto <D.19207>;
      <D.19206>:
      D.19188 = *_objptr;
      gc_debug_file.46 = gc_debug_file;
      fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19188, __old);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19207>:
      <D.19205>:
      D.19211 = sgen_ptr_in_nursery (__copy);
      if (D.19211 != 0) goto <D.19212>; else goto <D.19209>;
      <D.19212>:
      D.19213 = sgen_ptr_in_nursery (_objptr);
      if (D.19213 == 0) goto <D.19214>; else goto <D.19209>;
      <D.19214>:
      iftmp.48 = 1;
      goto <D.19210>;
      <D.19209>:
      iftmp.48 = 0;
      <D.19210>:
      D.19215 = iftmp.48 != 0;
      D.19216 = (long int) D.19215;
      D.19217 = __builtin_expect (D.19216, 0);
      if (D.19217 != 0) goto <D.19218>; else goto <D.19219>;
      <D.19218>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.19219>:
      <D.19203>:
    }
    _objptr = _objptr + 8;
    <D.18287>:
    if (_objptr < _objptr_end) goto <D.18286>; else goto <D.18288>;
    <D.18288>:
  }
  <D.19175>:
  goto <D.18289>;
  <D.18290>:
  {
    void * * _objptr;
    gsize _bmap;

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

      _index = __builtin_ctzl (_bmap);
      D.19220 = (long unsigned int) _index;
      D.19221 = D.19220 * 8;
      _objptr = _objptr + D.19221;
      D.19222 = _index + 1;
      _bmap = _bmap >> D.19222;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19223>; else goto <D.19224>;
        <D.19223>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19225>; else goto <D.19226>;
        <D.19225>:
        if (__old != __copy) goto <D.19227>; else goto <D.19228>;
        <D.19227>:
        D.19229 = *_objptr;
        gc_debug_file.46 = gc_debug_file;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19229, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19228>:
        <D.19226>:
        D.19233 = sgen_ptr_in_nursery (__copy);
        if (D.19233 != 0) goto <D.19234>; else goto <D.19231>;
        <D.19234>:
        D.19235 = sgen_ptr_in_nursery (_objptr);
        if (D.19235 == 0) goto <D.19236>; else goto <D.19231>;
        <D.19236>:
        iftmp.49 = 1;
        goto <D.19232>;
        <D.19231>:
        iftmp.49 = 0;
        <D.19232>:
        D.19237 = iftmp.49 != 0;
        D.19238 = (long int) D.19237;
        D.19239 = __builtin_expect (D.19238, 0);
        if (D.19239 != 0) goto <D.19240>; else goto <D.19241>;
        <D.19240>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19241>:
        <D.19224>:
      }
      _objptr = _objptr + 8;
    }
    goto <D.18300>;
    <D.18299>:
    {
      int _index;

      _index = __builtin_ctzl (_bmap);
      D.19242 = (long unsigned int) _index;
      D.19243 = D.19242 * 8;
      _objptr = _objptr + D.19243;
      D.19244 = _index + 1;
      _bmap = _bmap >> D.19244;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19245>; else goto <D.19246>;
        <D.19245>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19247>; else goto <D.19248>;
        <D.19247>:
        if (__old != __copy) goto <D.19249>; else goto <D.19250>;
        <D.19249>:
        D.19229 = *_objptr;
        gc_debug_file.46 = gc_debug_file;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19229, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19250>:
        <D.19248>:
        D.19254 = sgen_ptr_in_nursery (__copy);
        if (D.19254 != 0) goto <D.19255>; else goto <D.19252>;
        <D.19255>:
        D.19256 = sgen_ptr_in_nursery (_objptr);
        if (D.19256 == 0) goto <D.19257>; else goto <D.19252>;
        <D.19257>:
        iftmp.50 = 1;
        goto <D.19253>;
        <D.19252>:
        iftmp.50 = 0;
        <D.19253>:
        D.19258 = iftmp.50 != 0;
        D.19259 = (long int) D.19258;
        D.19260 = __builtin_expect (D.19259, 0);
        if (D.19260 != 0) goto <D.19261>; else goto <D.19262>;
        <D.19261>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19262>:
        <D.19246>:
      }
      _objptr = _objptr + 8;
    }
    <D.18300>:
    if (_bmap != 0) goto <D.18299>; else goto <D.18301>;
    <D.18301>:
  }
  goto <D.18289>;
  <D.18302>:
  D.19263 = desc & 4294950912;
  if (D.19263 != 0) goto <D.19264>; else goto <D.19265>;
  <D.19264>:
  {
    int el_size;
    int etype;

    D.19266 = desc >> 3;
    D.19267 = (int) D.19266;
    el_size = D.19267 & 1023;
    D.19268 = (int) desc;
    etype = D.19268 & 49152;
    if (etype == 16384) goto <D.19269>; else goto <D.19270>;
    <D.19269>:
    {
      void * * p;
      void * * end_refs;

      p = start + 32;
      D.19271 = MEM[(struct MonoArray *)start].max_length;
      el_size.51 = (unsigned int) el_size;
      D.19273 = D.19271 * el_size.51;
      D.19274 = (sizetype) D.19273;
      end_refs = p + D.19274;
      goto <D.18310>;
      <D.18309>:
      {
        void * __old;
        void * __copy;

        __old = *p;
        if (__old != 0B) goto <D.19275>; else goto <D.19276>;
        <D.19275>:
        split_nursery_parallel_copy_object (p, queue);
        __copy = *p;
        if (0 != 0) goto <D.19277>; else goto <D.19278>;
        <D.19277>:
        if (__old != __copy) goto <D.19279>; else goto <D.19280>;
        <D.19279>:
        D.19281 = *p;
        gc_debug_file.46 = gc_debug_file;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", p, D.19281, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19280>:
        <D.19278>:
        D.19285 = sgen_ptr_in_nursery (__copy);
        if (D.19285 != 0) goto <D.19286>; else goto <D.19283>;
        <D.19286>:
        D.19287 = sgen_ptr_in_nursery (p);
        if (D.19287 == 0) goto <D.19288>; else goto <D.19283>;
        <D.19288>:
        iftmp.52 = 1;
        goto <D.19284>;
        <D.19283>:
        iftmp.52 = 0;
        <D.19284>:
        D.19289 = iftmp.52 != 0;
        D.19290 = (long int) D.19289;
        D.19291 = __builtin_expect (D.19290, 0);
        if (D.19291 != 0) goto <D.19292>; else goto <D.19293>;
        <D.19292>:
        sgen_add_to_global_remset (p, __copy);
        <D.19293>:
        <D.19276>:
      }
      p = p + 8;
      <D.18310>:
      if (p < end_refs) goto <D.18309>; else goto <D.18311>;
      <D.18311>:
    }
    goto <D.19294>;
    <D.19270>:
    if (etype == 32768) goto <D.19295>; else goto <D.19296>;
    <D.19295>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.19176 = desc >> 16;
      D.19297 = (int) D.19176;
      offset = D.19297 & 255;
      D.19179 = desc >> 24;
      D.19298 = (int) D.19179;
      num_refs = D.19298 & 255;
      e_start = start + 32;
      D.19271 = MEM[(struct MonoArray *)start].max_length;
      el_size.51 = (unsigned int) el_size;
      D.19273 = D.19271 * el_size.51;
      D.19274 = (sizetype) D.19273;
      e_end = e_start + D.19274;
      goto <D.18324>;
      <D.18323>:
      {
        void * * p;
        int i;

        p = e_start;
        D.19299 = (long unsigned int) offset;
        D.19300 = D.19299 * 8;
        p = p + D.19300;
        i = 0;
        goto <D.18321>;
        <D.18320>:
        {
          void * __old;
          void * __copy;

          D.19301 = (long unsigned int) i;
          D.19302 = D.19301 * 8;
          D.19303 = p + D.19302;
          __old = *D.19303;
          if (__old != 0B) goto <D.19304>; else goto <D.19305>;
          <D.19304>:
          D.19301 = (long unsigned int) i;
          D.19302 = D.19301 * 8;
          D.19303 = p + D.19302;
          split_nursery_parallel_copy_object (D.19303, queue);
          D.19301 = (long unsigned int) i;
          D.19302 = D.19301 * 8;
          D.19303 = p + D.19302;
          __copy = *D.19303;
          if (0 != 0) goto <D.19306>; else goto <D.19307>;
          <D.19306>:
          if (__old != __copy) goto <D.19308>; else goto <D.19309>;
          <D.19308>:
          D.19301 = (long unsigned int) i;
          D.19302 = D.19301 * 8;
          D.19303 = p + D.19302;
          D.19310 = *D.19303;
          D.19301 = (long unsigned int) i;
          D.19302 = D.19301 * 8;
          D.19303 = p + D.19302;
          gc_debug_file.46 = gc_debug_file;
          fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", D.19303, D.19310, __old);
          gc_debug_file.46 = gc_debug_file;
          fflush (gc_debug_file.46);
          <D.19309>:
          <D.19307>:
          D.19314 = sgen_ptr_in_nursery (__copy);
          if (D.19314 != 0) goto <D.19315>; else goto <D.19312>;
          <D.19315>:
          D.19301 = (long unsigned int) i;
          D.19302 = D.19301 * 8;
          D.19316 = p + D.19302;
          D.19317 = sgen_ptr_in_nursery (D.19316);
          if (D.19317 == 0) goto <D.19318>; else goto <D.19312>;
          <D.19318>:
          iftmp.53 = 1;
          goto <D.19313>;
          <D.19312>:
          iftmp.53 = 0;
          <D.19313>:
          D.19319 = iftmp.53 != 0;
          D.19320 = (long int) D.19319;
          D.19321 = __builtin_expect (D.19320, 0);
          if (D.19321 != 0) goto <D.19322>; else goto <D.19323>;
          <D.19322>:
          D.19301 = (long unsigned int) i;
          D.19302 = D.19301 * 8;
          D.19324 = p + D.19302;
          sgen_add_to_global_remset (D.19324, __copy);
          <D.19323>:
          <D.19305>:
        }
        i = i + 1;
        <D.18321>:
        if (i < num_refs) goto <D.18320>; else goto <D.18322>;
        <D.18322>:
        D.19325 = (sizetype) el_size;
        e_start = e_start + D.19325;
      }
      <D.18324>:
      if (e_start < e_end) goto <D.18323>; else goto <D.18325>;
      <D.18325>:
    }
    goto <D.19326>;
    <D.19296>:
    if (etype == 49152) goto <D.19327>; else goto <D.19328>;
    <D.19327>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 32;
      D.19271 = MEM[(struct MonoArray *)start].max_length;
      el_size.51 = (unsigned int) el_size;
      D.19273 = D.19271 * el_size.51;
      D.19274 = (sizetype) D.19273;
      e_end = e_start + D.19274;
      goto <D.18336>;
      <D.18335>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.18333>;
        <D.18332>:
        D.19329 = _bmap & 1;
        if (D.19329 != 0) goto <D.19330>; else goto <D.19331>;
        <D.19330>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.19332>; else goto <D.19333>;
          <D.19332>:
          split_nursery_parallel_copy_object (p, queue);
          __copy = *p;
          if (0 != 0) goto <D.19334>; else goto <D.19335>;
          <D.19334>:
          if (__old != __copy) goto <D.19336>; else goto <D.19337>;
          <D.19336>:
          D.19338 = *p;
          gc_debug_file.46 = gc_debug_file;
          fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", p, D.19338, __old);
          gc_debug_file.46 = gc_debug_file;
          fflush (gc_debug_file.46);
          <D.19337>:
          <D.19335>:
          D.19342 = sgen_ptr_in_nursery (__copy);
          if (D.19342 != 0) goto <D.19343>; else goto <D.19340>;
          <D.19343>:
          D.19344 = sgen_ptr_in_nursery (p);
          if (D.19344 == 0) goto <D.19345>; else goto <D.19340>;
          <D.19345>:
          iftmp.54 = 1;
          goto <D.19341>;
          <D.19340>:
          iftmp.54 = 0;
          <D.19341>:
          D.19346 = iftmp.54 != 0;
          D.19347 = (long int) D.19346;
          D.19348 = __builtin_expect (D.19347, 0);
          if (D.19348 != 0) goto <D.19349>; else goto <D.19350>;
          <D.19349>:
          sgen_add_to_global_remset (p, __copy);
          <D.19350>:
          <D.19333>:
        }
        <D.19331>:
        _bmap = _bmap >> 1;
        p = p + 8;
        <D.18333>:
        if (_bmap != 0) goto <D.18332>; else goto <D.18334>;
        <D.18334>:
        D.19325 = (sizetype) el_size;
        e_start = e_start + D.19325;
      }
      <D.18336>:
      if (e_start < e_end) goto <D.18335>; else goto <D.18337>;
      <D.18337>:
    }
    <D.19328>:
    <D.19326>:
    <D.19294>:
  }
  <D.19265>:
  goto <D.18289>;
  <D.18338>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 3;
    _objptr = _objptr + 16;
    goto <D.18344>;
    <D.18343>:
    D.19351 = _bmap & 1;
    if (D.19351 != 0) goto <D.19352>; else goto <D.19353>;
    <D.19352>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.19354>; else goto <D.19355>;
      <D.19354>:
      split_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.19356>; else goto <D.19357>;
      <D.19356>:
      if (__old != __copy) goto <D.19358>; else goto <D.19359>;
      <D.19358>:
      D.19360 = *_objptr;
      gc_debug_file.46 = gc_debug_file;
      fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19360, __old);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19359>:
      <D.19357>:
      D.19364 = sgen_ptr_in_nursery (__copy);
      if (D.19364 != 0) goto <D.19365>; else goto <D.19362>;
      <D.19365>:
      D.19366 = sgen_ptr_in_nursery (_objptr);
      if (D.19366 == 0) goto <D.19367>; else goto <D.19362>;
      <D.19367>:
      iftmp.55 = 1;
      goto <D.19363>;
      <D.19362>:
      iftmp.55 = 0;
      <D.19363>:
      D.19368 = iftmp.55 != 0;
      D.19369 = (long int) D.19368;
      D.19370 = __builtin_expect (D.19369, 0);
      if (D.19370 != 0) goto <D.19371>; else goto <D.19372>;
      <D.19371>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.19372>:
      <D.19355>:
    }
    <D.19353>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 8;
    <D.18344>:
    if (_bmap != 0) goto <D.18343>; else goto <D.18345>;
    <D.18345>:
  }
  goto <D.18289>;
  <D.18346>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.19373 = *bitmap_data;
    D.19374 = (unsigned int) D.19373;
    D.19375 = D.19374 + 4294967295;
    bwords = (int) D.19375;
    start_run = _objptr;
    bitmap_data = bitmap_data + 8;
    if (0 != 0) goto <D.19376>; else goto <D.19377>;
    <D.19376>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.19378 = myobj->vtable;
      D.19379 = D.19378->klass;
      D.19380 = D.19379->name;
      D.19378 = myobj->vtable;
      D.19379 = D.19378->klass;
      D.19381 = D.19379->name_space;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19381, D.19380);
    }
    <D.19377>:
    goto <D.18359>;
    <D.18358>:
    {
      gsize _bmap;

      bitmap_data.56 = bitmap_data;
      bitmap_data = bitmap_data.56 + 8;
      _bmap = *bitmap_data.56;
      _objptr = start_run;
      goto <D.18356>;
      <D.18355>:
      D.19383 = _bmap & 1;
      if (D.19383 != 0) goto <D.19384>; else goto <D.19385>;
      <D.19384>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19386>; else goto <D.19387>;
        <D.19386>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19388>; else goto <D.19389>;
        <D.19388>:
        if (__old != __copy) goto <D.19390>; else goto <D.19391>;
        <D.19390>:
        D.19392 = *_objptr;
        gc_debug_file.46 = gc_debug_file;
        fprintf (gc_debug_file.46, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19392, __old);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19391>:
        <D.19389>:
        D.19396 = sgen_ptr_in_nursery (__copy);
        if (D.19396 != 0) goto <D.19397>; else goto <D.19394>;
        <D.19397>:
        D.19398 = sgen_ptr_in_nursery (_objptr);
        if (D.19398 == 0) goto <D.19399>; else goto <D.19394>;
        <D.19399>:
        iftmp.57 = 1;
        goto <D.19395>;
        <D.19394>:
        iftmp.57 = 0;
        <D.19395>:
        D.19400 = iftmp.57 != 0;
        D.19401 = (long int) D.19400;
        D.19402 = __builtin_expect (D.19401, 0);
        if (D.19402 != 0) goto <D.19403>; else goto <D.19404>;
        <D.19403>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19404>:
        <D.19387>:
      }
      <D.19385>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18356>:
      if (_bmap != 0) goto <D.18355>; else goto <D.18357>;
      <D.18357>:
      start_run = start_run + 512;
    }
    <D.18359>:
    bwords.58 = bwords;
    bwords = bwords.58 + -1;
    if (bwords.58 > 0) goto <D.18358>; else goto <D.18360>;
    <D.18360>:
  }
  goto <D.18289>;
  <D.18361>:
  goto <D.18289>;
  <D.18362>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.18289>:
}


split_nursery_parallel_scan_object (char * start, struct SgenGrayQueue * queue)
{
  long unsigned int D.19407;
  long unsigned int D.19408;
  long unsigned int D.19409;
  long unsigned int D.19410;
  long unsigned int D.19413;
  long unsigned int D.19414;
  long unsigned int D.19415;
  long unsigned int D.19416;
  long unsigned int D.19417;
  long unsigned int D.19418;
  void * D.19425;
  struct FILE * gc_debug_file.59;
  int iftmp.60;
  int D.19430;
  int D.19432;
  _Bool D.19434;
  long int D.19435;
  long int D.19436;
  int iftmp.61;
  int D.19448;
  int D.19450;
  _Bool D.19452;
  long int D.19453;
  long int D.19454;
  long unsigned int D.19457;
  long unsigned int D.19458;
  int D.19459;
  void * D.19466;
  int iftmp.62;
  int D.19470;
  int D.19472;
  _Bool D.19474;
  long int D.19475;
  long int D.19476;
  long unsigned int D.19479;
  long unsigned int D.19480;
  int D.19481;
  int iftmp.63;
  int D.19491;
  int D.19493;
  _Bool D.19495;
  long int D.19496;
  long int D.19497;
  long unsigned int D.19500;
  long unsigned int D.19503;
  int D.19504;
  int D.19505;
  unsigned int D.19508;
  unsigned int el_size.64;
  unsigned int D.19510;
  sizetype D.19511;
  void * D.19518;
  int iftmp.65;
  int D.19522;
  int D.19524;
  _Bool D.19526;
  long int D.19527;
  long int D.19528;
  int D.19534;
  int D.19535;
  long unsigned int D.19536;
  long unsigned int D.19537;
  long unsigned int D.19538;
  long unsigned int D.19539;
  void * * D.19540;
  void * D.19547;
  int iftmp.66;
  int D.19551;
  void * D.19553;
  int D.19554;
  _Bool D.19556;
  long int D.19557;
  long int D.19558;
  void * D.19561;
  sizetype D.19562;
  long unsigned int D.19566;
  void * D.19575;
  int iftmp.67;
  int D.19579;
  int D.19581;
  _Bool D.19583;
  long int D.19584;
  long int D.19585;
  long unsigned int D.19588;
  void * D.19597;
  int iftmp.68;
  int D.19601;
  int D.19603;
  _Bool D.19605;
  long int D.19606;
  long int D.19607;
  long unsigned int D.19610;
  unsigned int D.19611;
  unsigned int D.19612;
  struct MonoVTable * D.19615;
  struct MonoClass * D.19616;
  const char * D.19617;
  const char * D.19618;
  gsize * bitmap_data.69;
  long unsigned int D.19620;
  void * D.19629;
  int iftmp.70;
  int D.19633;
  int D.19635;
  _Bool D.19637;
  long int D.19638;
  long int D.19639;
  int bwords.71;
  long unsigned int D.19643;
  gsize * mbitmap_data.72;
  long unsigned int D.19645;
  unsigned int D.19646;
  unsigned int D.19647;
  struct MonoClass * D.19648;
  unsigned int el_size.73;
  unsigned int D.19650;
  sizetype D.19651;
  const char * D.19654;
  const char * D.19655;
  gsize * bitmap_data.74;
  long unsigned int D.19657;
  void * D.19666;
  int iftmp.75;
  int D.19670;
  int D.19672;
  _Bool D.19674;
  long int D.19675;
  long int D.19676;
  unsigned int bwords.76;
  sizetype D.19680;

  {
    struct GCVTable * vt;
    mword desc;

    D.19407 = MEM[(mword *)start];
    D.19408 = D.19407 & 18446744073709551612;
    vt = (struct GCVTable *) D.19408;
    desc = vt->desc;
    D.19409 = desc & 7;
    switch (D.19409) <default: <D.18273>, case 1: <D.18168>, case 2: <D.18179>, case 3: <D.18235>, case 4: <D.18191>, case 5: <D.18227>, case 6: <D.18250>, case 7: <D.18272>>
    <D.18168>:
    D.19410 = desc & 4294901760;
    if (D.19410 != 0) goto <D.19411>; else goto <D.19412>;
    <D.19411>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19413 = desc >> 16;
      D.19414 = D.19413 & 255;
      D.19415 = D.19414 * 8;
      _objptr = _objptr + D.19415;
      D.19416 = desc >> 24;
      D.19417 = D.19416 & 255;
      D.19418 = D.19417 * 8;
      _objptr_end = _objptr + D.19418;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19419>; else goto <D.19420>;
        <D.19419>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19421>; else goto <D.19422>;
        <D.19421>:
        if (__old != __copy) goto <D.19423>; else goto <D.19424>;
        <D.19423>:
        D.19425 = *_objptr;
        gc_debug_file.59 = gc_debug_file;
        fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19425, __old);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.19424>:
        <D.19422>:
        D.19430 = sgen_ptr_in_nursery (__copy);
        if (D.19430 != 0) goto <D.19431>; else goto <D.19428>;
        <D.19431>:
        D.19432 = sgen_ptr_in_nursery (_objptr);
        if (D.19432 == 0) goto <D.19433>; else goto <D.19428>;
        <D.19433>:
        iftmp.60 = 1;
        goto <D.19429>;
        <D.19428>:
        iftmp.60 = 0;
        <D.19429>:
        D.19434 = iftmp.60 != 0;
        D.19435 = (long int) D.19434;
        D.19436 = __builtin_expect (D.19435, 0);
        if (D.19436 != 0) goto <D.19437>; else goto <D.19438>;
        <D.19437>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19438>:
        <D.19420>:
      }
      _objptr = _objptr + 8;
      goto <D.18176>;
      <D.18175>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19439>; else goto <D.19440>;
        <D.19439>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19441>; else goto <D.19442>;
        <D.19441>:
        if (__old != __copy) goto <D.19443>; else goto <D.19444>;
        <D.19443>:
        D.19425 = *_objptr;
        gc_debug_file.59 = gc_debug_file;
        fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19425, __old);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.19444>:
        <D.19442>:
        D.19448 = sgen_ptr_in_nursery (__copy);
        if (D.19448 != 0) goto <D.19449>; else goto <D.19446>;
        <D.19449>:
        D.19450 = sgen_ptr_in_nursery (_objptr);
        if (D.19450 == 0) goto <D.19451>; else goto <D.19446>;
        <D.19451>:
        iftmp.61 = 1;
        goto <D.19447>;
        <D.19446>:
        iftmp.61 = 0;
        <D.19447>:
        D.19452 = iftmp.61 != 0;
        D.19453 = (long int) D.19452;
        D.19454 = __builtin_expect (D.19453, 0);
        if (D.19454 != 0) goto <D.19455>; else goto <D.19456>;
        <D.19455>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19456>:
        <D.19440>:
      }
      _objptr = _objptr + 8;
      <D.18176>:
      if (_objptr < _objptr_end) goto <D.18175>; else goto <D.18177>;
      <D.18177>:
    }
    <D.19412>:
    goto <D.18178>;
    <D.18179>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.19457 = (long unsigned int) _index;
        D.19458 = D.19457 * 8;
        _objptr = _objptr + D.19458;
        D.19459 = _index + 1;
        _bmap = _bmap >> D.19459;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.19460>; else goto <D.19461>;
          <D.19460>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.19462>; else goto <D.19463>;
          <D.19462>:
          if (__old != __copy) goto <D.19464>; else goto <D.19465>;
          <D.19464>:
          D.19466 = *_objptr;
          gc_debug_file.59 = gc_debug_file;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19466, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.19465>:
          <D.19463>:
          D.19470 = sgen_ptr_in_nursery (__copy);
          if (D.19470 != 0) goto <D.19471>; else goto <D.19468>;
          <D.19471>:
          D.19472 = sgen_ptr_in_nursery (_objptr);
          if (D.19472 == 0) goto <D.19473>; else goto <D.19468>;
          <D.19473>:
          iftmp.62 = 1;
          goto <D.19469>;
          <D.19468>:
          iftmp.62 = 0;
          <D.19469>:
          D.19474 = iftmp.62 != 0;
          D.19475 = (long int) D.19474;
          D.19476 = __builtin_expect (D.19475, 0);
          if (D.19476 != 0) goto <D.19477>; else goto <D.19478>;
          <D.19477>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.19478>:
          <D.19461>:
        }
        _objptr = _objptr + 8;
      }
      goto <D.18189>;
      <D.18188>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.19479 = (long unsigned int) _index;
        D.19480 = D.19479 * 8;
        _objptr = _objptr + D.19480;
        D.19481 = _index + 1;
        _bmap = _bmap >> D.19481;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.19482>; else goto <D.19483>;
          <D.19482>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.19484>; else goto <D.19485>;
          <D.19484>:
          if (__old != __copy) goto <D.19486>; else goto <D.19487>;
          <D.19486>:
          D.19466 = *_objptr;
          gc_debug_file.59 = gc_debug_file;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19466, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.19487>:
          <D.19485>:
          D.19491 = sgen_ptr_in_nursery (__copy);
          if (D.19491 != 0) goto <D.19492>; else goto <D.19489>;
          <D.19492>:
          D.19493 = sgen_ptr_in_nursery (_objptr);
          if (D.19493 == 0) goto <D.19494>; else goto <D.19489>;
          <D.19494>:
          iftmp.63 = 1;
          goto <D.19490>;
          <D.19489>:
          iftmp.63 = 0;
          <D.19490>:
          D.19495 = iftmp.63 != 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>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.19499>:
          <D.19483>:
        }
        _objptr = _objptr + 8;
      }
      <D.18189>:
      if (_bmap != 0) goto <D.18188>; else goto <D.18190>;
      <D.18190>:
    }
    goto <D.18178>;
    <D.18191>:
    D.19500 = desc & 4294950912;
    if (D.19500 != 0) goto <D.19501>; else goto <D.19502>;
    <D.19501>:
    {
      int el_size;
      int etype;

      D.19503 = desc >> 3;
      D.19504 = (int) D.19503;
      el_size = D.19504 & 1023;
      D.19505 = (int) desc;
      etype = D.19505 & 49152;
      if (etype == 16384) goto <D.19506>; else goto <D.19507>;
      <D.19506>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.19508 = MEM[(struct MonoArray *)start].max_length;
        el_size.64 = (unsigned int) el_size;
        D.19510 = D.19508 * el_size.64;
        D.19511 = (sizetype) D.19510;
        end_refs = p + D.19511;
        goto <D.18199>;
        <D.18198>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.19512>; else goto <D.19513>;
          <D.19512>:
          split_nursery_parallel_copy_object (p, queue);
          __copy = *p;
          if (0 != 0) goto <D.19514>; else goto <D.19515>;
          <D.19514>:
          if (__old != __copy) goto <D.19516>; else goto <D.19517>;
          <D.19516>:
          D.19518 = *p;
          gc_debug_file.59 = gc_debug_file;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", p, D.19518, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.19517>:
          <D.19515>:
          D.19522 = sgen_ptr_in_nursery (__copy);
          if (D.19522 != 0) goto <D.19523>; else goto <D.19520>;
          <D.19523>:
          D.19524 = sgen_ptr_in_nursery (p);
          if (D.19524 == 0) goto <D.19525>; else goto <D.19520>;
          <D.19525>:
          iftmp.65 = 1;
          goto <D.19521>;
          <D.19520>:
          iftmp.65 = 0;
          <D.19521>:
          D.19526 = iftmp.65 != 0;
          D.19527 = (long int) D.19526;
          D.19528 = __builtin_expect (D.19527, 0);
          if (D.19528 != 0) goto <D.19529>; else goto <D.19530>;
          <D.19529>:
          sgen_add_to_global_remset (p, __copy);
          <D.19530>:
          <D.19513>:
        }
        p = p + 8;
        <D.18199>:
        if (p < end_refs) goto <D.18198>; else goto <D.18200>;
        <D.18200>:
      }
      goto <D.19531>;
      <D.19507>:
      if (etype == 32768) goto <D.19532>; else goto <D.19533>;
      <D.19532>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19413 = desc >> 16;
        D.19534 = (int) D.19413;
        offset = D.19534 & 255;
        D.19416 = desc >> 24;
        D.19535 = (int) D.19416;
        num_refs = D.19535 & 255;
        e_start = start + 32;
        D.19508 = MEM[(struct MonoArray *)start].max_length;
        el_size.64 = (unsigned int) el_size;
        D.19510 = D.19508 * el_size.64;
        D.19511 = (sizetype) D.19510;
        e_end = e_start + D.19511;
        goto <D.18213>;
        <D.18212>:
        {
          void * * p;
          int i;

          p = e_start;
          D.19536 = (long unsigned int) offset;
          D.19537 = D.19536 * 8;
          p = p + D.19537;
          i = 0;
          goto <D.18210>;
          <D.18209>:
          {
            void * __old;
            void * __copy;

            D.19538 = (long unsigned int) i;
            D.19539 = D.19538 * 8;
            D.19540 = p + D.19539;
            __old = *D.19540;
            if (__old != 0B) goto <D.19541>; else goto <D.19542>;
            <D.19541>:
            D.19538 = (long unsigned int) i;
            D.19539 = D.19538 * 8;
            D.19540 = p + D.19539;
            split_nursery_parallel_copy_object (D.19540, queue);
            D.19538 = (long unsigned int) i;
            D.19539 = D.19538 * 8;
            D.19540 = p + D.19539;
            __copy = *D.19540;
            if (0 != 0) goto <D.19543>; else goto <D.19544>;
            <D.19543>:
            if (__old != __copy) goto <D.19545>; else goto <D.19546>;
            <D.19545>:
            D.19538 = (long unsigned int) i;
            D.19539 = D.19538 * 8;
            D.19540 = p + D.19539;
            D.19547 = *D.19540;
            D.19538 = (long unsigned int) i;
            D.19539 = D.19538 * 8;
            D.19540 = p + D.19539;
            gc_debug_file.59 = gc_debug_file;
            fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", D.19540, D.19547, __old);
            gc_debug_file.59 = gc_debug_file;
            fflush (gc_debug_file.59);
            <D.19546>:
            <D.19544>:
            D.19551 = sgen_ptr_in_nursery (__copy);
            if (D.19551 != 0) goto <D.19552>; else goto <D.19549>;
            <D.19552>:
            D.19538 = (long unsigned int) i;
            D.19539 = D.19538 * 8;
            D.19553 = p + D.19539;
            D.19554 = sgen_ptr_in_nursery (D.19553);
            if (D.19554 == 0) goto <D.19555>; else goto <D.19549>;
            <D.19555>:
            iftmp.66 = 1;
            goto <D.19550>;
            <D.19549>:
            iftmp.66 = 0;
            <D.19550>:
            D.19556 = iftmp.66 != 0;
            D.19557 = (long int) D.19556;
            D.19558 = __builtin_expect (D.19557, 0);
            if (D.19558 != 0) goto <D.19559>; else goto <D.19560>;
            <D.19559>:
            D.19538 = (long unsigned int) i;
            D.19539 = D.19538 * 8;
            D.19561 = p + D.19539;
            sgen_add_to_global_remset (D.19561, __copy);
            <D.19560>:
            <D.19542>:
          }
          i = i + 1;
          <D.18210>:
          if (i < num_refs) goto <D.18209>; else goto <D.18211>;
          <D.18211>:
          D.19562 = (sizetype) el_size;
          e_start = e_start + D.19562;
        }
        <D.18213>:
        if (e_start < e_end) goto <D.18212>; else goto <D.18214>;
        <D.18214>:
      }
      goto <D.19563>;
      <D.19533>:
      if (etype == 49152) goto <D.19564>; else goto <D.19565>;
      <D.19564>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.19508 = MEM[(struct MonoArray *)start].max_length;
        el_size.64 = (unsigned int) el_size;
        D.19510 = D.19508 * el_size.64;
        D.19511 = (sizetype) D.19510;
        e_end = e_start + D.19511;
        goto <D.18225>;
        <D.18224>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.18222>;
          <D.18221>:
          D.19566 = _bmap & 1;
          if (D.19566 != 0) goto <D.19567>; else goto <D.19568>;
          <D.19567>:
          {
            void * __old;
            void * __copy;

            __old = *p;
            if (__old != 0B) goto <D.19569>; else goto <D.19570>;
            <D.19569>:
            split_nursery_parallel_copy_object (p, queue);
            __copy = *p;
            if (0 != 0) goto <D.19571>; else goto <D.19572>;
            <D.19571>:
            if (__old != __copy) goto <D.19573>; else goto <D.19574>;
            <D.19573>:
            D.19575 = *p;
            gc_debug_file.59 = gc_debug_file;
            fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", p, D.19575, __old);
            gc_debug_file.59 = gc_debug_file;
            fflush (gc_debug_file.59);
            <D.19574>:
            <D.19572>:
            D.19579 = sgen_ptr_in_nursery (__copy);
            if (D.19579 != 0) goto <D.19580>; else goto <D.19577>;
            <D.19580>:
            D.19581 = sgen_ptr_in_nursery (p);
            if (D.19581 == 0) goto <D.19582>; else goto <D.19577>;
            <D.19582>:
            iftmp.67 = 1;
            goto <D.19578>;
            <D.19577>:
            iftmp.67 = 0;
            <D.19578>:
            D.19583 = iftmp.67 != 0;
            D.19584 = (long int) D.19583;
            D.19585 = __builtin_expect (D.19584, 0);
            if (D.19585 != 0) goto <D.19586>; else goto <D.19587>;
            <D.19586>:
            sgen_add_to_global_remset (p, __copy);
            <D.19587>:
            <D.19570>:
          }
          <D.19568>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.18222>:
          if (_bmap != 0) goto <D.18221>; else goto <D.18223>;
          <D.18223>:
          D.19562 = (sizetype) el_size;
          e_start = e_start + D.19562;
        }
        <D.18225>:
        if (e_start < e_end) goto <D.18224>; else goto <D.18226>;
        <D.18226>:
      }
      <D.19565>:
      <D.19563>:
      <D.19531>:
    }
    <D.19502>:
    goto <D.18178>;
    <D.18227>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.18233>;
      <D.18232>:
      D.19588 = _bmap & 1;
      if (D.19588 != 0) goto <D.19589>; else goto <D.19590>;
      <D.19589>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.19591>; else goto <D.19592>;
        <D.19591>:
        split_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.19593>; else goto <D.19594>;
        <D.19593>:
        if (__old != __copy) goto <D.19595>; else goto <D.19596>;
        <D.19595>:
        D.19597 = *_objptr;
        gc_debug_file.59 = gc_debug_file;
        fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19597, __old);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.19596>:
        <D.19594>:
        D.19601 = sgen_ptr_in_nursery (__copy);
        if (D.19601 != 0) goto <D.19602>; else goto <D.19599>;
        <D.19602>:
        D.19603 = sgen_ptr_in_nursery (_objptr);
        if (D.19603 == 0) goto <D.19604>; else goto <D.19599>;
        <D.19604>:
        iftmp.68 = 1;
        goto <D.19600>;
        <D.19599>:
        iftmp.68 = 0;
        <D.19600>:
        D.19605 = iftmp.68 != 0;
        D.19606 = (long int) D.19605;
        D.19607 = __builtin_expect (D.19606, 0);
        if (D.19607 != 0) goto <D.19608>; else goto <D.19609>;
        <D.19608>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.19609>:
        <D.19592>:
      }
      <D.19590>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18233>:
      if (_bmap != 0) goto <D.18232>; else goto <D.18234>;
      <D.18234>:
    }
    goto <D.18178>;
    <D.18235>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19610 = *bitmap_data;
      D.19611 = (unsigned int) D.19610;
      D.19612 = D.19611 + 4294967295;
      bwords = (int) D.19612;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.19613>; else goto <D.19614>;
      <D.19613>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19615 = myobj->vtable;
        D.19616 = D.19615->klass;
        D.19617 = D.19616->name;
        D.19615 = myobj->vtable;
        D.19616 = D.19615->klass;
        D.19618 = D.19616->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19618, D.19617);
      }
      <D.19614>:
      goto <D.18248>;
      <D.18247>:
      {
        gsize _bmap;

        bitmap_data.69 = bitmap_data;
        bitmap_data = bitmap_data.69 + 8;
        _bmap = *bitmap_data.69;
        _objptr = start_run;
        goto <D.18245>;
        <D.18244>:
        D.19620 = _bmap & 1;
        if (D.19620 != 0) goto <D.19621>; else goto <D.19622>;
        <D.19621>:
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.19623>; else goto <D.19624>;
          <D.19623>:
          split_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.19625>; else goto <D.19626>;
          <D.19625>:
          if (__old != __copy) goto <D.19627>; else goto <D.19628>;
          <D.19627>:
          D.19629 = *_objptr;
          gc_debug_file.59 = gc_debug_file;
          fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19629, __old);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.19628>:
          <D.19626>:
          D.19633 = sgen_ptr_in_nursery (__copy);
          if (D.19633 != 0) goto <D.19634>; else goto <D.19631>;
          <D.19634>:
          D.19635 = sgen_ptr_in_nursery (_objptr);
          if (D.19635 == 0) goto <D.19636>; else goto <D.19631>;
          <D.19636>:
          iftmp.70 = 1;
          goto <D.19632>;
          <D.19631>:
          iftmp.70 = 0;
          <D.19632>:
          D.19637 = iftmp.70 != 0;
          D.19638 = (long int) D.19637;
          D.19639 = __builtin_expect (D.19638, 0);
          if (D.19639 != 0) goto <D.19640>; else goto <D.19641>;
          <D.19640>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.19641>:
          <D.19624>:
        }
        <D.19622>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18245>:
        if (_bmap != 0) goto <D.18244>; else goto <D.18246>;
        <D.18246>:
        start_run = start_run + 512;
      }
      <D.18248>:
      bwords.71 = bwords;
      bwords = bwords.71 + -1;
      if (bwords.71 > 0) goto <D.18247>; else goto <D.18249>;
      <D.18249>:
    }
    goto <D.18178>;
    <D.18250>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19643 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19643);
      mbitmap_data.72 = mbitmap_data;
      mbitmap_data = mbitmap_data.72 + 8;
      D.19645 = *mbitmap_data.72;
      D.19646 = (unsigned int) D.19645;
      D.19647 = D.19646 + 4294967295;
      mbwords = (int) D.19647;
      D.19648 = vt->klass;
      el_size = mono_array_element_size (D.19648);
      e_start = start + 32;
      D.19508 = MEM[(struct MonoArray *)start].max_length;
      el_size.73 = (unsigned int) el_size;
      D.19650 = D.19508 * el_size.73;
      D.19651 = (sizetype) D.19650;
      e_end = e_start + D.19651;
      if (0 != 0) goto <D.19652>; else goto <D.19653>;
      <D.19652>:
      D.19648 = vt->klass;
      D.19654 = D.19648->name;
      D.19648 = vt->klass;
      D.19655 = D.19648->name_space;
      D.19643 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19643, D.19655, D.19654);
      <D.19653>:
      goto <D.18270>;
      <D.18269>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.18267>;
        <D.18266>:
        {
          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.18264>;
          <D.18263>:
          D.19657 = _bmap & 1;
          if (D.19657 != 0) goto <D.19658>; else goto <D.19659>;
          <D.19658>:
          {
            void * __old;
            void * __copy;

            __old = *_objptr;
            if (__old != 0B) goto <D.19660>; else goto <D.19661>;
            <D.19660>:
            split_nursery_parallel_copy_object (_objptr, queue);
            __copy = *_objptr;
            if (0 != 0) goto <D.19662>; else goto <D.19663>;
            <D.19662>:
            if (__old != __copy) goto <D.19664>; else goto <D.19665>;
            <D.19664>:
            D.19666 = *_objptr;
            gc_debug_file.59 = gc_debug_file;
            fprintf (gc_debug_file.59, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.19666, __old);
            gc_debug_file.59 = gc_debug_file;
            fflush (gc_debug_file.59);
            <D.19665>:
            <D.19663>:
            D.19670 = sgen_ptr_in_nursery (__copy);
            if (D.19670 != 0) goto <D.19671>; else goto <D.19668>;
            <D.19671>:
            D.19672 = sgen_ptr_in_nursery (_objptr);
            if (D.19672 == 0) goto <D.19673>; else goto <D.19668>;
            <D.19673>:
            iftmp.75 = 1;
            goto <D.19669>;
            <D.19668>:
            iftmp.75 = 0;
            <D.19669>:
            D.19674 = iftmp.75 != 0;
            D.19675 = (long int) D.19674;
            D.19676 = __builtin_expect (D.19675, 0);
            if (D.19676 != 0) goto <D.19677>; else goto <D.19678>;
            <D.19677>:
            sgen_add_to_global_remset (_objptr, __copy);
            <D.19678>:
            <D.19661>:
          }
          <D.19659>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18264>:
          if (_bmap != 0) goto <D.18263>; else goto <D.18265>;
          <D.18265>:
          _objptr = start_run + 512;
        }
        <D.18267>:
        bwords.76 = bwords;
        bwords = bwords.76 + 4294967295;
        if (bwords.76 != 0) goto <D.18266>; else goto <D.18268>;
        <D.18268>:
        D.19680 = (sizetype) el_size;
        e_start = e_start + D.19680;
      }
      <D.18270>:
      if (e_start < e_end) goto <D.18269>; else goto <D.18271>;
      <D.18271>:
    }
    goto <D.18178>;
    <D.18272>:
    goto <D.18178>;
    <D.18273>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.18178>:
  }
}


split_nursery_parallel_copy_object (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.77;
  int D.19685;
  long unsigned int D.19688;
  long unsigned int D.19689;
  long unsigned int D.19692;
  int D.19695;
  unsigned int D.19698;
  unsigned int D.19699;
  long unsigned int D.19700;
  void * D.19701;
  long unsigned int D.19702;
  _Bool D.19703;
  long int D.19704;
  long int D.19705;
  long unsigned int destination.78;
  long unsigned int D.19709;
  void * D.19710;
  void * D.19711;
  struct SgenGrayQueue * iftmp.79;
  int D.19719;
  _Bool D.19723;
  long int D.19724;
  long int D.19725;
  char * obj;
  mword vtable_word;
  mword objsize;
  struct MonoVTable * vt;
  void * destination;
  gboolean has_references;

  obj = *obj_slot;
  if (0 != 0) goto <D.19682>; else goto <D.19683>;
  <D.19682>:
  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.18160>:
  goto <D.18160>;
  <D.19683>:
  D.19685 = sgen_ptr_in_nursery (obj);
  if (D.19685 == 0) goto <D.19686>; else goto <D.19687>;
  <D.19686>:
  return;
  <D.19687>:
  vtable_word = MEM[(mword *)obj];
  D.19688 = vtable_word & 18446744073709551612;
  vt = (struct MonoVTable *) D.19688;
  D.19689 = vtable_word & 1;
  if (D.19689 != 0) goto <D.19690>; else goto <D.19691>;
  <D.19690>:
  *obj_slot = vt;
  return;
  <D.19691>:
  D.19692 = vtable_word & 2;
  if (D.19692 != 0) goto <D.19693>; else goto <D.19694>;
  <D.19693>:
  return;
  <D.19694>:
  D.19695 = sgen_nursery_is_to_space (obj);
  if (D.19695 != 0) goto <D.19696>; else goto <D.19697>;
  <D.19696>:
  return;
  <D.19697>:
  D.19698 = sgen_par_object_get_size (vt, obj);
  D.19699 = D.19698 + 7;
  D.19700 = (long unsigned int) D.19699;
  objsize = D.19700 & 4294967288;
  D.19701 = vt->gc_descr;
  D.19702 = (long unsigned int) D.19701;
  has_references = sgen_gc_descr_has_references (D.19702);
  destination = par_alloc_for_promotion (vt, obj, objsize, has_references);
  D.19703 = destination == 0B;
  D.19704 = (long int) D.19703;
  D.19705 = __builtin_expect (D.19704, 0);
  if (D.19705 != 0) goto <D.19706>; else goto <D.19707>;
  <D.19706>:
  sgen_parallel_pin_or_update (obj_slot, obj, vt, queue);
  return;
  <D.19707>:
  MEM[(struct MonoVTable * *)destination] = vt;
  destination.78 = (long unsigned int) destination;
  D.19709 = destination.78 | 1;
  D.19710 = (void *) D.19709;
  D.19711 = InterlockedCompareExchangePointer (obj, D.19710, vt);
  if (D.19711 == vt) goto <D.19712>; else goto <D.19713>;
  <D.19712>:
  if (has_references != 0) goto <D.19715>; else goto <D.19716>;
  <D.19715>:
  iftmp.79 = queue;
  goto <D.19717>;
  <D.19716>:
  iftmp.79 = 0B;
  <D.19717>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.79);
  obj = destination;
  *obj_slot = obj;
  goto <D.19718>;
  <D.19713>:
  D.19719 = sgen_ptr_in_nursery (destination);
  if (D.19719 == 0) goto <D.19720>; else goto <D.19721>;
  <D.19720>:
  MEM[(void * *)destination] = 0B;
  goto <D.19722>;
  <D.19721>:
  memset (destination, 0, objsize);
  <D.19722>:
  vtable_word = MEM[(mword *)obj];
  D.19689 = vtable_word & 1;
  D.19723 = D.19689 == 0;
  D.19724 = (long int) D.19723;
  D.19725 = __builtin_expect (D.19724, 0);
  if (D.19725 != 0) goto <D.19726>; else goto <D.19727>;
  <D.19726>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-minor-copy-object.h", 291, "vtable_word & SGEN_FORWARDED_BIT");
  <D.19727>:
  D.19688 = vtable_word & 18446744073709551612;
  obj = (char *) D.19688;
  *obj_slot = obj;
  <D.19718>:
}


par_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int promote_age.80;
  char * D.19732;
  void * (*<T2e87>) (struct MonoVTable *, int, gboolean) D.19733;
  int D.19734;
  char * D.19735;
  char * D.19736;
  _Bool D.19737;
  long int D.19738;
  long int D.19739;
  void * D.19742;
  char * * D.19743;
  void * D.19744;
  char * p;
  int age;
  void restart = <<< error >>>;

  age = get_object_age (obj);
  promote_age.80 = promote_age;
  if (age >= promote_age.80) goto <D.19730>; else goto <D.19731>;
  <D.19730>:
  D.19733 = major_collector.par_alloc_object;
  D.19734 = (int) objsize;
  D.19732 = D.19733 (vtable, D.19734, has_references);
  return D.19732;
  <D.19731>:
  restart:
  p = age_alloc_buffers[age].next;
  D.19735 = p + objsize;
  D.19736 = age_alloc_buffers[age].end;
  D.19737 = D.19735 <= D.19736;
  D.19738 = (long int) D.19737;
  D.19739 = __builtin_expect (D.19738, 1);
  if (D.19739 != 0) goto <D.19740>; else goto <D.19741>;
  <D.19740>:
  D.19742 = p + objsize;
  D.19743 = &age_alloc_buffers[age].next;
  D.19744 = InterlockedCompareExchangePointer (D.19743, D.19742, p);
  if (D.19744 != p) goto restart; else goto <D.19745>;
  <D.19745>:
  goto <D.19746>;
  <D.19741>:
  p = par_alloc_for_promotion_slow_path (age, objsize);
  if (p == 0B) goto <D.19747>; else goto <D.19748>;
  <D.19747>:
  D.19733 = major_collector.par_alloc_object;
  D.19734 = (int) objsize;
  D.19732 = D.19733 (vtable, D.19734, has_references);
  return D.19732;
  <D.19748>:
  <D.19746>:
  MEM[(struct MonoVTable * *)p] = vtable;
  D.19732 = p;
  return D.19732;
}


par_alloc_for_promotion_slow_path (int age, size_t objsize)
{
  long unsigned int D.19750;
  char * D.19751;
  char * D.19752;
  _Bool D.19753;
  long int D.19754;
  long int D.19755;
  void * D.19758;
  char * * D.19759;
  void * D.19760;
  void * D.19765;
  long unsigned int D.19766;
  long unsigned int D.19767;
  long unsigned int allocated_size.81;
  char * D.19771;
  char * D.19772;
  char * p;
  size_t allocated_size;
  size_t aligned_objsize;
  void restart = <<< error >>>;

  try
    {
      D.19750 = objsize + 511;
      aligned_objsize = D.19750 & 18446744073709551104;
      pthread_mutex_lock (&par_alloc_buffer_refill_mutex);
      restart:
      p = age_alloc_buffers[age].next;
      D.19751 = p + objsize;
      D.19752 = age_alloc_buffers[age].end;
      D.19753 = D.19751 <= D.19752;
      D.19754 = (long int) D.19753;
      D.19755 = __builtin_expect (D.19754, 1);
      if (D.19755 != 0) goto <D.19756>; else goto <D.19757>;
      <D.19756>:
      D.19758 = p + objsize;
      D.19759 = &age_alloc_buffers[age].next;
      D.19760 = InterlockedCompareExchangePointer (D.19759, D.19758, p);
      if (D.19760 != p) goto restart; else goto <D.19761>;
      <D.19761>:
      goto <D.19762>;
      <D.19757>:
      {
        char * end;

        end = age_alloc_buffers[age].end;
        if (end != 0B) goto <D.19763>; else goto <D.19764>;
        <D.19763>:
        <D.18027>:
        p = age_alloc_buffers[age].next;
        D.19759 = &age_alloc_buffers[age].next;
        D.19765 = InterlockedCompareExchangePointer (D.19759, end, p);
        if (D.19765 != p) goto <D.18027>; else goto <D.18028>;
        <D.18028>:
        sgen_clear_range (p, end);
        <D.19764>:
        age_alloc_buffers[age].end = 0B;
        D.19766 = MAX_EXPR <aligned_objsize, 512>;
        D.19767 = MAX_EXPR <aligned_objsize, 4096>;
        p = sgen_fragment_allocator_par_range_alloc (&collector_allocator, D.19767, D.19766, &allocated_size);
        if (p != 0B) goto <D.19768>; else goto <D.19769>;
        <D.19768>:
        allocated_size.81 = allocated_size;
        D.19771 = p + allocated_size.81;
        set_age_in_range (p, D.19771, age);
        D.19751 = p + objsize;
        age_alloc_buffers[age].next = D.19751;
        allocated_size.81 = allocated_size;
        D.19771 = p + allocated_size.81;
        age_alloc_buffers[age].end = D.19771;
        <D.19769>:
      }
      <D.19762>:
      pthread_mutex_unlock (&par_alloc_buffer_refill_mutex);
      D.19772 = p;
      return D.19772;
    }
  finally
    {
      allocated_size = {CLOBBER};
    }
}


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

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


split_nursery_serial_copy_object (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.84;
  int D.19783;
  struct FILE * gc_debug_file.85;
  char * iftmp.86;
  long unsigned int D.19790;
  long unsigned int D.19791;
  long unsigned int D.19794;
  long unsigned int D.19802;
  _Bool D.19803;
  long int D.19804;
  long int D.19805;
  int D.19812;
  void * D.19819;
  char * forwarded;
  char * obj;

  obj = *obj_slot;
  if (0 != 0) goto <D.19780>; else goto <D.19781>;
  <D.19780>:
  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.18135>:
  goto <D.18135>;
  <D.19781>:
  D.19783 = sgen_ptr_in_nursery (obj);
  if (D.19783 == 0) goto <D.19784>; else goto <D.19785>;
  <D.19784>:
  return;
  <D.19785>:
  if (0 != 0) goto <D.19786>; else goto <D.19787>;
  <D.19786>:
  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.19787>:
  D.19790 = MEM[(mword *)obj];
  D.19791 = D.19790 & 1;
  if (D.19791 != 0) goto <D.19792>; else goto <D.19793>;
  <D.19792>:
  D.19790 = MEM[(mword *)obj];
  D.19794 = D.19790 & 18446744073709551612;
  iftmp.86 = (char *) D.19794;
  goto <D.19795>;
  <D.19793>:
  iftmp.86 = 0B;
  <D.19795>:
  forwarded = iftmp.86;
  if (forwarded != 0B) goto <D.19796>; else goto <D.19797>;
  <D.19796>:
  if (0 != 0) goto <D.19798>; else goto <D.19799>;
  <D.19798>:
  monoeg_g_log (0B, 4, "forwarded object %p has no gc descriptor", forwarded);
  <D.18136>:
  goto <D.18136>;
  <D.19799>:
  if (0 != 0) goto <D.19800>; else goto <D.19801>;
  <D.19800>:
  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.19801>:
  *obj_slot = forwarded;
  return;
  <D.19797>:
  D.19790 = MEM[(mword *)obj];
  D.19802 = D.19790 & 2;
  D.19803 = D.19802 != 0;
  D.19804 = (long int) D.19803;
  D.19805 = __builtin_expect (D.19804, 0);
  if (D.19805 != 0) goto <D.19806>; else goto <D.19807>;
  <D.19806>:
  if (0 != 0) goto <D.19808>; else goto <D.19809>;
  <D.19808>:
  monoeg_g_log (0B, 4, "pinned object %p has no gc descriptor", obj);
  <D.18137>:
  goto <D.18137>;
  <D.19809>:
  if (0 != 0) goto <D.19810>; else goto <D.19811>;
  <D.19810>:
  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.19811>:
  return;
  <D.19807>:
  D.19812 = sgen_nursery_is_to_space (obj);
  if (D.19812 != 0) goto <D.19813>; else goto <D.19814>;
  <D.19813>:
  if (0 != 0) goto <D.19815>; else goto <D.19816>;
  <D.19815>:
  monoeg_g_log (0B, 4, "to space object %p has no gc descriptor", obj);
  <D.18138>:
  goto <D.18138>;
  <D.19816>:
  if (0 != 0) goto <D.19817>; else goto <D.19818>;
  <D.19817>:
  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.19818>:
  return;
  <D.19814>:
  D.19819 = copy_object_no_checks (obj, queue);
  *obj_slot = D.19819;
}


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

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


handle_gc_param (const char * opt)
{
  int D.19824;
  char * D.19827;
  unsigned int percentage.88;
  unsigned int D.19829;
  struct _IO_FILE * stderr.89;
  float D.19833;
  float alloc_ratio.90;
  gboolean D.19835;
  int D.19836;
  char * D.19839;
  int promote_age.91;
  int promote_age.92;
  unsigned int promote_age.93;
  unsigned int D.19843;

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

    D.19827 = __builtin_strchr (opt, 61);
    arg = D.19827 + 1;
    percentage = atoi (arg);
    percentage.88 = (unsigned int) percentage;
    D.19829 = percentage.88 + 4294967295;
    if (D.19829 > 99) goto <D.19830>; else goto <D.19831>;
    <D.19830>:
    stderr.89 = stderr;
    fprintf (stderr.89, "alloc-ratio must be an integer in the range 1-100.\n");
    exit (1);
    <D.19831>:
    D.19833 = (float) percentage;
    alloc_ratio.90 = D.19833 / 1.0e+2;
    alloc_ratio = alloc_ratio.90;
    D.19835 = 1;
    return D.19835;
  }
  <D.19826>:
  D.19836 = monoeg_g_str_has_prefix (opt, "promotion-age=");
  if (D.19836 != 0) goto <D.19837>; else goto <D.19838>;
  <D.19837>:
  {
    const char * arg;

    D.19839 = __builtin_strchr (opt, 61);
    arg = D.19839 + 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.19843 = promote_age.93 + 4294967295;
    if (D.19843 > 13) goto <D.19844>; else goto <D.19845>;
    <D.19844>:
    stderr.89 = stderr;
    fprintf (stderr.89, "promotion-age must be an integer in the range 1-%d.\n", 14);
    exit (1);
    <D.19845>:
    D.19835 = 1;
    return D.19835;
  }
  <D.19838>:
  D.19835 = 0;
  return D.19835;
}


atoi (const char * __nptr)
{
  int D.19847;
  long int D.19848;

  D.19848 = strtol (__nptr, 0B, 10);
  D.19847 = (int) D.19848;
  return D.19847;
}


init_nursery (struct SgenFragmentAllocator * allocator, char * start, char * end)
{
  long int end.94;
  long int start.95;
  long int D.19852;
  float D.19853;
  float alloc_ratio.96;
  float D.19855;
  long unsigned int D.19856;
  long unsigned int start.97;
  long unsigned int D.19858;
  long unsigned int D.19859;
  char * promotion_barrier.98;
  char * promotion_barrier.99;
  long int D.19862;
  int region_age_size.100;
  int region_age_size.101;
  long unsigned int D.19865;
  void * region_age.102;
  int alloc_quote;

  end.94 = (long int) end;
  start.95 = (long int) start;
  D.19852 = end.94 - start.95;
  D.19853 = (float) D.19852;
  alloc_ratio.96 = alloc_ratio;
  D.19855 = D.19853 * alloc_ratio.96;
  alloc_quote = (int) D.19855;
  D.19856 = (long unsigned int) alloc_quote;
  start.97 = (long unsigned int) start;
  D.19858 = D.19856 + start.97;
  D.19859 = D.19858 & 18446744073709551608;
  promotion_barrier.98 = (char *) D.19859;
  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.19852 = end.94 - start.95;
  D.19862 = D.19852 >> 9;
  region_age_size.100 = (int) D.19862;
  region_age_size = region_age_size.100;
  region_age_size.101 = region_age_size;
  D.19865 = (long unsigned int) region_age_size.101;
  region_age.102 = monoeg_malloc0 (D.19865);
  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.19867;
  char * promotion_barrier.103;
  char * D.19871;
  struct SgenFragment * D.19874;
  struct SgenFragment * D.19875;
  char * D.19876;
  char * D.19877;
  _Bool D.19878;
  long int D.19879;
  long int D.19880;
  struct SgenFragment * D.19883;
  struct SgenFragment * D.19886;
  struct SgenFragment * prev;
  struct SgenFragment * list;

  prev = 0B;
  list = allocator->region_head;
  goto <D.18001>;
  <D.18000>:
  D.19867 = list->fragment_end;
  promotion_barrier.103 = promotion_barrier;
  if (D.19867 > promotion_barrier.103) goto <D.19869>; else goto <D.19870>;
  <D.19869>:
  D.19871 = list->fragment_start;
  promotion_barrier.103 = promotion_barrier;
  if (D.19871 < promotion_barrier.103) goto <D.19872>; else goto <D.19873>;
  <D.19872>:
  {
    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.19867 = list->fragment_end;
    res->fragment_end = D.19867;
    D.19874 = list->next;
    res->next = D.19874;
    D.19875 = list->next_in_order;
    res->next_in_order = D.19875;
    D.19876 = res->fragment_end;
    D.19877 = res->fragment_start;
    D.19878 = D.19876 <= D.19877;
    D.19879 = (long int) D.19878;
    D.19880 = __builtin_expect (D.19879, 0);
    if (D.19880 != 0) goto <D.19881>; else goto <D.19882>;
    <D.19881>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-split-nursery.c", 220, "res->fragment_end > res->fragment_start");
    <D.19882>:
    promotion_barrier.103 = promotion_barrier;
    list->fragment_end = promotion_barrier.103;
    list->next_in_order = 0B;
    D.19875 = list->next_in_order;
    list->next = D.19875;
    D.19867 = list->fragment_end;
    D.19871 = list->fragment_start;
    set_age_in_range (D.19871, D.19867, 0);
    allocator->alloc_head = res;
    D.19883 = allocator->alloc_head;
    allocator->region_head = D.19883;
    return;
  }
  <D.19873>:
  if (prev != 0B) goto <D.19884>; else goto <D.19885>;
  <D.19884>:
  prev->next_in_order = 0B;
  D.19886 = prev->next_in_order;
  prev->next = D.19886;
  <D.19885>:
  allocator->alloc_head = list;
  D.19883 = allocator->alloc_head;
  allocator->region_head = D.19883;
  return;
  <D.19870>:
  D.19867 = list->fragment_end;
  D.19871 = list->fragment_start;
  set_age_in_range (D.19871, D.19867, 0);
  prev = list;
  list = list->next;
  <D.18001>:
  if (list != 0B) goto <D.18000>; else goto <D.18002>;
  <D.18002>:
  allocator->alloc_head = 0B;
  D.19883 = allocator->alloc_head;
  allocator->region_head = D.19883;
}


build_fragments_release_exclude_head ()
{
  sgen_fragment_allocator_release (&collector_allocator);
}


build_fragments_get_exclude_head ()
{
  char * D.19888;
  char * D.19891;
  struct SgenFragment * D.19892;
  int i;

  i = 0;
  goto <D.18055>;
  <D.18054>:
  D.19888 = age_alloc_buffers[i].end;
  if (D.19888 != 0B) goto <D.19889>; else goto <D.19890>;
  <D.19889>:
  D.19888 = age_alloc_buffers[i].end;
  D.19891 = age_alloc_buffers[i].next;
  sgen_clear_range (D.19891, D.19888);
  <D.19890>:
  i = i + 1;
  <D.18055>:
  if (i <= 14) goto <D.18054>; else goto <D.18056>;
  <D.18056>:
  D.19892 = collector_allocator.region_head;
  return D.19892;
}


clear_fragments ()
{
  sgen_clear_allocator_fragments (&collector_allocator);
}


prepare_to_space (char * to_space_bitmap, int space_bitmap_size)
{
  long unsigned int D.19894;
  char * D.19895;
  long unsigned int D.19896;
  long unsigned int D.19897;
  long unsigned int D.19898;
  char * D.19899;
  long unsigned int D.19900;
  long unsigned int D.19901;
  long int end.104;
  long int start.105;
  long int D.19904;
  char * D.19907;
  struct SgenFragment * D.19908;
  struct SgenFragment * * previous;
  struct SgenFragment * frag;

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

    D.19895 = frag->fragment_next;
    D.19896 = (long unsigned int) D.19895;
    D.19897 = D.19896 + 511;
    D.19898 = D.19897 & 18446744073709551104;
    start = (char *) D.19898;
    D.19899 = frag->fragment_end;
    D.19900 = (long unsigned int) D.19899;
    D.19901 = D.19900 & 18446744073709551104;
    end = (char *) D.19901;
    end.104 = (long int) end;
    start.105 = (long int) start;
    D.19904 = end.104 - start.105;
    if (D.19904 <= 511) goto <D.19905>; else goto <D.19906>;
    <D.19905>:
    D.19899 = frag->fragment_end;
    D.19895 = frag->fragment_next;
    sgen_clear_range (D.19895, D.19899);
    D.19907 = frag->fragment_start;
    frag->fragment_end = D.19907;
    D.19899 = frag->fragment_end;
    frag->fragment_next = D.19899;
    D.19908 = frag->next;
    *previous = D.19908;
    // predicted unlikely by continue predictor.
    goto <D.18071>;
    <D.19906>:
    sgen_clear_range (start, end);
    D.19895 = frag->fragment_next;
    if (D.19895 != start) goto <D.19909>; else goto <D.19910>;
    <D.19909>:
    D.19895 = frag->fragment_next;
    sgen_clear_range (D.19895, start);
    <D.19910>:
    D.19899 = frag->fragment_end;
    if (D.19899 != end) goto <D.19911>; else goto <D.19912>;
    <D.19911>:
    D.19899 = frag->fragment_end;
    sgen_clear_range (end, D.19899);
    <D.19912>:
    frag->fragment_next = start;
    D.19895 = frag->fragment_next;
    frag->fragment_start = D.19895;
    frag->fragment_end = end;
    mark_bits_in_range (to_space_bitmap, start, end);
    previous = &frag->next;
  }
  <D.18071>:
  frag = *previous;
  <D.18073>:
  if (frag != 0B) goto <D.18072>; else goto <D.18074>;
  <D.18074>:
}


mark_bits_in_range (char * space_bitmap, char * start, char * end)
{
  long unsigned int start.106;
  long unsigned int D.19914;
  long unsigned int end.107;
  long unsigned int D.19916;
  long unsigned int D.19917;

  start.106 = (long unsigned int) start;
  D.19914 = start.106 & 18446744073709551104;
  start = (char *) D.19914;
  end.107 = (long unsigned int) end;
  D.19916 = end.107 + 511;
  D.19917 = D.19916 & 18446744073709551104;
  end = (char *) D.19917;
  goto <D.17992>;
  <D.17991>:
  mark_bit (space_bitmap, start);
  start = start + 512;
  <D.17992>:
  if (start < end) goto <D.17991>; else goto <D.17993>;
  <D.17993>:
}


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.19921;
  long int D.19922;
  int sgen_space_bitmap_size.111;
  _Bool D.19924;
  long int D.19925;
  long int D.19926;
  sizetype D.19929;
  char * D.19930;
  char D.19931;
  int D.19932;
  char D.19933;
  char D.19934;
  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.19921 = pos.108 - sgen_nursery_start.110;
  D.19922 = D.19921 >> 9;
  idx = (int) D.19922;
  byte = idx / 8;
  bit = idx & 7;
  sgen_space_bitmap_size.111 = sgen_space_bitmap_size;
  D.19924 = byte >= sgen_space_bitmap_size.111;
  D.19925 = (long int) D.19924;
  D.19926 = __builtin_expect (D.19925, 0);
  if (D.19926 != 0) goto <D.19927>; else goto <D.19928>;
  <D.19927>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-split-nursery.c", 182, "byte < sgen_space_bitmap_size");
  <D.19928>:
  D.19929 = (sizetype) byte;
  D.19930 = space_bitmap + D.19929;
  D.19929 = (sizetype) byte;
  D.19930 = space_bitmap + D.19929;
  D.19931 = *D.19930;
  D.19932 = 1 << bit;
  D.19933 = (char) D.19932;
  D.19934 = D.19931 | D.19933;
  *D.19930 = D.19934;
}


minor_par_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int D.19935;
  char * D.19938;
  void * (*<T2e87>) (struct MonoVTable *, int, gboolean) D.19939;
  int D.19940;

  D.19935 = sgen_ptr_in_nursery (obj);
  if (D.19935 == 0) goto <D.19936>; else goto <D.19937>;
  <D.19936>:
  D.19939 = major_collector.par_alloc_object;
  D.19940 = (int) objsize;
  D.19938 = D.19939 (vtable, D.19940, has_references);
  return D.19938;
  <D.19937>:
  D.19938 = par_alloc_for_promotion (vtable, obj, objsize, has_references);
  return D.19938;
}


minor_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  int D.19942;
  char * D.19945;
  void * (*<T2e87>) (struct MonoVTable *, int, gboolean) D.19946;
  int D.19947;

  D.19942 = sgen_ptr_in_nursery (obj);
  if (D.19942 == 0) goto <D.19943>; else goto <D.19944>;
  <D.19943>:
  D.19946 = major_collector.alloc_object;
  D.19947 = (int) objsize;
  D.19945 = D.19946 (vtable, D.19947, has_references);
  return D.19945;
  <D.19944>:
  D.19945 = alloc_for_promotion (vtable, obj, objsize, has_references);
  return D.19945;
}