sgen_simple_nursery_init (struct SgenMinorCollector * collector)
{
  collector->is_split = 0;
  collector->alloc_for_promotion = alloc_for_promotion;
  collector->par_alloc_for_promotion = 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->serial_ops.copy_or_mark_object = simple_nursery_serial_copy_object;
  collector->parallel_ops.copy_or_mark_object = simple_nursery_parallel_copy_object;
  collector->parallel_ops.scan_object = simple_nursery_parallel_scan_object;
  collector->parallel_ops.scan_vtype = simple_nursery_parallel_scan_vtype;
  collector->serial_ops.scan_object = simple_nursery_serial_scan_object;
  collector->serial_ops.scan_vtype = simple_nursery_serial_scan_vtype;
}


simple_nursery_serial_scan_vtype (char * start, mword desc, struct SgenGrayQueue * queue)
{
  unsigned int D.20633;
  unsigned int D.20634;
  unsigned int D.20637;
  unsigned int D.20638;
  unsigned int D.20639;
  unsigned int D.20640;
  unsigned int D.20641;
  void * D.20646;
  struct FILE * gc_debug_file.0;
  unsigned int _index.1;
  unsigned int D.20657;
  int D.20658;
  void * D.20663;
  unsigned int _index.2;
  unsigned int D.20667;
  int D.20668;
  unsigned int D.20675;
  unsigned int D.20678;
  int D.20679;
  int desc.3;
  unsigned int D.20683;
  unsigned int el_size.4;
  unsigned int D.20685;
  void * D.20690;
  int D.20696;
  unsigned int offset.5;
  unsigned int D.20698;
  unsigned int i.6;
  unsigned int D.20700;
  void * * D.20701;
  void * D.20706;
  sizetype el_size.7;
  unsigned int D.20713;
  void * D.20720;
  unsigned int D.20723;
  void * D.20730;
  unsigned int D.20733;
  unsigned int D.20734;
  struct MonoVTable * D.20737;
  struct MonoClass * D.20738;
  const char * D.20739;
  const char * D.20740;
  gsize * bitmap_data.8;
  unsigned int D.20742;
  void * D.20749;
  int bwords.9;

  start = start + 4294967288;
  D.20633 = desc & 7;
  switch (D.20633) <default: <D.20626>, case 1: <D.20552>, case 2: <D.20561>, case 3: <D.20611>, case 4: <D.20571>, case 5: <D.20604>, case 7: <D.20625>>
  <D.20552>:
  D.20634 = desc & 4294901760;
  if (D.20634 != 0) goto <D.20635>; else goto <D.20636>;
  <D.20635>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.20637 = desc >> 16;
    D.20638 = D.20637 & 255;
    D.20639 = D.20638 * 4;
    _objptr = _objptr + D.20639;
    D.20640 = desc >> 24;
    D.20641 = D.20640 * 4;
    _objptr_end = _objptr + D.20641;
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.20642>; else goto <D.20643>;
      <D.20642>:
      simple_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.20644>; else goto <D.20645>;
      <D.20644>:
      D.20646 = *_objptr;
      if (D.20646 != __old) goto <D.20647>; else goto <D.20648>;
      <D.20647>:
      gc_debug_file.0 = gc_debug_file;
      D.20646 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20646, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.20648>:
      <D.20645>:
      <D.20643>:
    }
    _objptr = _objptr + 4;
    goto <D.20558>;
    <D.20557>:
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.20650>; else goto <D.20651>;
      <D.20650>:
      simple_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.20652>; else goto <D.20653>;
      <D.20652>:
      D.20646 = *_objptr;
      if (D.20646 != __old) goto <D.20654>; else goto <D.20655>;
      <D.20654>:
      gc_debug_file.0 = gc_debug_file;
      D.20646 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20646, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.20655>:
      <D.20653>:
      <D.20651>:
    }
    _objptr = _objptr + 4;
    <D.20558>:
    if (_objptr < _objptr_end) goto <D.20557>; else goto <D.20559>;
    <D.20559>:
  }
  <D.20636>:
  goto <D.20560>;
  <D.20561>:
  {
    void * * _objptr;
    gsize _bmap;

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

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

        __old = *_objptr;
        if (__old != 0B) goto <D.20659>; else goto <D.20660>;
        <D.20659>:
        simple_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.20661>; else goto <D.20662>;
        <D.20661>:
        D.20663 = *_objptr;
        if (D.20663 != __old) goto <D.20664>; else goto <D.20665>;
        <D.20664>:
        gc_debug_file.0 = gc_debug_file;
        D.20663 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20663, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.20665>:
        <D.20662>:
        <D.20660>:
      }
      _objptr = _objptr + 4;
    }
    goto <D.20569>;
    <D.20568>:
    {
      int _index;

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

        __old = *_objptr;
        if (__old != 0B) goto <D.20669>; else goto <D.20670>;
        <D.20669>:
        simple_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.20671>; else goto <D.20672>;
        <D.20671>:
        D.20663 = *_objptr;
        if (D.20663 != __old) goto <D.20673>; else goto <D.20674>;
        <D.20673>:
        gc_debug_file.0 = gc_debug_file;
        D.20663 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20663, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.20674>:
        <D.20672>:
        <D.20670>:
      }
      _objptr = _objptr + 4;
    }
    <D.20569>:
    if (_bmap != 0) goto <D.20568>; else goto <D.20570>;
    <D.20570>:
  }
  goto <D.20560>;
  <D.20571>:
  D.20675 = desc & 4294950912;
  if (D.20675 != 0) goto <D.20676>; else goto <D.20677>;
  <D.20676>:
  {
    int el_size;
    int etype;

    D.20678 = desc >> 3;
    D.20679 = (int) D.20678;
    el_size = D.20679 & 1023;
    desc.3 = (int) desc;
    etype = desc.3 & 49152;
    if (etype == 16384) goto <D.20681>; else goto <D.20682>;
    <D.20681>:
    {
      void * * p;
      void * * end_refs;

      p = start + 16;
      D.20683 = MEM[(struct MonoArray *)start].max_length;
      el_size.4 = (unsigned int) el_size;
      D.20685 = D.20683 * el_size.4;
      end_refs = p + D.20685;
      goto <D.20578>;
      <D.20577>:
      {
        void * __old;

        __old = *p;
        if (__old != 0B) goto <D.20686>; else goto <D.20687>;
        <D.20686>:
        simple_nursery_serial_copy_object_from_obj (p, queue);
        if (0 != 0) goto <D.20688>; else goto <D.20689>;
        <D.20688>:
        D.20690 = *p;
        if (D.20690 != __old) goto <D.20691>; else goto <D.20692>;
        <D.20691>:
        gc_debug_file.0 = gc_debug_file;
        D.20690 = *p;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", p, D.20690, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.20692>:
        <D.20689>:
        <D.20687>:
      }
      p = p + 4;
      <D.20578>:
      if (p < end_refs) goto <D.20577>; else goto <D.20579>;
      <D.20579>:
    }
    goto <D.20693>;
    <D.20682>:
    if (etype == 32768) goto <D.20694>; else goto <D.20695>;
    <D.20694>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.20637 = desc >> 16;
      D.20696 = (int) D.20637;
      offset = D.20696 & 255;
      D.20640 = desc >> 24;
      num_refs = (int) D.20640;
      e_start = start + 16;
      D.20683 = MEM[(struct MonoArray *)start].max_length;
      el_size.4 = (unsigned int) el_size;
      D.20685 = D.20683 * el_size.4;
      e_end = e_start + D.20685;
      goto <D.20591>;
      <D.20590>:
      {
        void * * p;
        int i;

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

          i.6 = (unsigned int) i;
          D.20700 = i.6 * 4;
          D.20701 = p + D.20700;
          __old = *D.20701;
          if (__old != 0B) goto <D.20702>; else goto <D.20703>;
          <D.20702>:
          i.6 = (unsigned int) i;
          D.20700 = i.6 * 4;
          D.20701 = p + D.20700;
          simple_nursery_serial_copy_object_from_obj (D.20701, queue);
          if (0 != 0) goto <D.20704>; else goto <D.20705>;
          <D.20704>:
          i.6 = (unsigned int) i;
          D.20700 = i.6 * 4;
          D.20701 = p + D.20700;
          D.20706 = *D.20701;
          if (D.20706 != __old) goto <D.20707>; else goto <D.20708>;
          <D.20707>:
          gc_debug_file.0 = gc_debug_file;
          i.6 = (unsigned int) i;
          D.20700 = i.6 * 4;
          D.20701 = p + D.20700;
          i.6 = (unsigned int) i;
          D.20700 = i.6 * 4;
          D.20701 = p + D.20700;
          D.20706 = *D.20701;
          fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", D.20701, D.20706, __old);
          gc_debug_file.0 = gc_debug_file;
          fflush (gc_debug_file.0);
          <D.20708>:
          <D.20705>:
          <D.20703>:
        }
        i = i + 1;
        <D.20588>:
        if (i < num_refs) goto <D.20587>; else goto <D.20589>;
        <D.20589>:
        el_size.7 = (sizetype) el_size;
        e_start = e_start + el_size.7;
      }
      <D.20591>:
      if (e_start < e_end) goto <D.20590>; else goto <D.20592>;
      <D.20592>:
    }
    goto <D.20710>;
    <D.20695>:
    if (etype == 49152) goto <D.20711>; else goto <D.20712>;
    <D.20711>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 16;
      D.20683 = MEM[(struct MonoArray *)start].max_length;
      el_size.4 = (unsigned int) el_size;
      D.20685 = D.20683 * el_size.4;
      e_end = e_start + D.20685;
      goto <D.20602>;
      <D.20601>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.20599>;
        <D.20598>:
        D.20713 = _bmap & 1;
        if (D.20713 != 0) goto <D.20714>; else goto <D.20715>;
        <D.20714>:
        {
          void * __old;

          __old = *p;
          if (__old != 0B) goto <D.20716>; else goto <D.20717>;
          <D.20716>:
          simple_nursery_serial_copy_object_from_obj (p, queue);
          if (0 != 0) goto <D.20718>; else goto <D.20719>;
          <D.20718>:
          D.20720 = *p;
          if (D.20720 != __old) goto <D.20721>; else goto <D.20722>;
          <D.20721>:
          gc_debug_file.0 = gc_debug_file;
          D.20720 = *p;
          fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", p, D.20720, __old);
          gc_debug_file.0 = gc_debug_file;
          fflush (gc_debug_file.0);
          <D.20722>:
          <D.20719>:
          <D.20717>:
        }
        <D.20715>:
        _bmap = _bmap >> 1;
        p = p + 4;
        <D.20599>:
        if (_bmap != 0) goto <D.20598>; else goto <D.20600>;
        <D.20600>:
        el_size.7 = (sizetype) el_size;
        e_start = e_start + el_size.7;
      }
      <D.20602>:
      if (e_start < e_end) goto <D.20601>; else goto <D.20603>;
      <D.20603>:
    }
    <D.20712>:
    <D.20710>:
    <D.20693>:
  }
  <D.20677>:
  goto <D.20560>;
  <D.20604>:
  {
    void * * _objptr;
    gsize _bmap;

    _objptr = start;
    _bmap = desc >> 3;
    _objptr = _objptr + 8;
    goto <D.20609>;
    <D.20608>:
    D.20723 = _bmap & 1;
    if (D.20723 != 0) goto <D.20724>; else goto <D.20725>;
    <D.20724>:
    {
      void * __old;

      __old = *_objptr;
      if (__old != 0B) goto <D.20726>; else goto <D.20727>;
      <D.20726>:
      simple_nursery_serial_copy_object_from_obj (_objptr, queue);
      if (0 != 0) goto <D.20728>; else goto <D.20729>;
      <D.20728>:
      D.20730 = *_objptr;
      if (D.20730 != __old) goto <D.20731>; else goto <D.20732>;
      <D.20731>:
      gc_debug_file.0 = gc_debug_file;
      D.20730 = *_objptr;
      fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20730, __old);
      gc_debug_file.0 = gc_debug_file;
      fflush (gc_debug_file.0);
      <D.20732>:
      <D.20729>:
      <D.20727>:
    }
    <D.20725>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 4;
    <D.20609>:
    if (_bmap != 0) goto <D.20608>; else goto <D.20610>;
    <D.20610>:
  }
  goto <D.20560>;
  <D.20611>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.20733 = *bitmap_data;
    D.20734 = D.20733 + 4294967295;
    bwords = (int) D.20734;
    start_run = _objptr;
    bitmap_data = bitmap_data + 4;
    if (0 != 0) goto <D.20735>; else goto <D.20736>;
    <D.20735>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.20737 = myobj->vtable;
      D.20738 = D.20737->klass;
      D.20739 = D.20738->name_space;
      D.20737 = myobj->vtable;
      D.20738 = D.20737->klass;
      D.20740 = D.20738->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.20739, D.20740);
    }
    <D.20736>:
    goto <D.20623>;
    <D.20622>:
    {
      gsize _bmap;

      bitmap_data.8 = bitmap_data;
      bitmap_data = bitmap_data.8 + 4;
      _bmap = *bitmap_data.8;
      _objptr = start_run;
      goto <D.20620>;
      <D.20619>:
      D.20742 = _bmap & 1;
      if (D.20742 != 0) goto <D.20743>; else goto <D.20744>;
      <D.20743>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.20745>; else goto <D.20746>;
        <D.20745>:
        simple_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.20747>; else goto <D.20748>;
        <D.20747>:
        D.20749 = *_objptr;
        if (D.20749 != __old) goto <D.20750>; else goto <D.20751>;
        <D.20750>:
        gc_debug_file.0 = gc_debug_file;
        D.20749 = *_objptr;
        fprintf (gc_debug_file.0, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20749, __old);
        gc_debug_file.0 = gc_debug_file;
        fflush (gc_debug_file.0);
        <D.20751>:
        <D.20748>:
        <D.20746>:
      }
      <D.20744>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20620>:
      if (_bmap != 0) goto <D.20619>; else goto <D.20621>;
      <D.20621>:
      start_run = start_run + 128;
    }
    <D.20623>:
    bwords.9 = bwords;
    bwords = bwords.9 + -1;
    if (bwords.9 > 0) goto <D.20622>; else goto <D.20624>;
    <D.20624>:
  }
  goto <D.20560>;
  <D.20625>:
  goto <D.20560>;
  <D.20626>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.20560>:
}


simple_nursery_serial_copy_object_from_obj (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.10;
  int D.20757;
  struct FILE * gc_debug_file.11;
  char * iftmp.12;
  unsigned int D.20764;
  unsigned int D.20765;
  unsigned int D.20768;
  unsigned int D.20776;
  _Bool D.20777;
  long int D.20778;
  long int D.20779;
  int D.20786;
  _Bool D.20789;
  long int D.20790;
  long int D.20791;
  int iftmp.13;
  int D.20797;
  int D.20799;
  _Bool D.20801;
  long int D.20802;
  long int D.20803;
  char * forwarded;
  char * obj;
  void * copy;

  obj = *obj_slot;
  if (0 != 0) goto <D.20754>; else goto <D.20755>;
  <D.20754>:
  current_collection_generation.10 = current_collection_generation;
  monoeg_g_log (0B, 4, "calling minor-serial-copy-from-obj from a %d generation collection", current_collection_generation.10);
  <D.20229>:
  goto <D.20229>;
  <D.20755>:
  D.20757 = sgen_ptr_in_nursery (obj);
  if (D.20757 == 0) goto <D.20758>; else goto <D.20759>;
  <D.20758>:
  return;
  <D.20759>:
  if (0 != 0) goto <D.20760>; else goto <D.20761>;
  <D.20760>:
  gc_debug_file.11 = gc_debug_file;
  fprintf (gc_debug_file.11, "Precise copy of %p from %p\n", obj, obj_slot);
  gc_debug_file.11 = gc_debug_file;
  fflush (gc_debug_file.11);
  <D.20761>:
  D.20764 = MEM[(mword *)obj];
  D.20765 = D.20764 & 1;
  if (D.20765 != 0) goto <D.20766>; else goto <D.20767>;
  <D.20766>:
  D.20764 = MEM[(mword *)obj];
  D.20768 = D.20764 & 4294967292;
  iftmp.12 = (char *) D.20768;
  goto <D.20769>;
  <D.20767>:
  iftmp.12 = 0B;
  <D.20769>:
  forwarded = iftmp.12;
  if (forwarded != 0B) goto <D.20770>; else goto <D.20771>;
  <D.20770>:
  if (0 != 0) goto <D.20772>; else goto <D.20773>;
  <D.20772>:
  monoeg_g_log (0B, 4, "forwarded object %p has no gc descriptor", forwarded);
  <D.20230>:
  goto <D.20230>;
  <D.20773>:
  if (0 != 0) goto <D.20774>; else goto <D.20775>;
  <D.20774>:
  gc_debug_file.11 = gc_debug_file;
  fprintf (gc_debug_file.11, " (already forwarded to %p)\n", forwarded);
  gc_debug_file.11 = gc_debug_file;
  fflush (gc_debug_file.11);
  <D.20775>:
  *obj_slot = forwarded;
  return;
  <D.20771>:
  D.20764 = MEM[(mword *)obj];
  D.20776 = D.20764 & 2;
  D.20777 = D.20776 != 0;
  D.20778 = (long int) D.20777;
  D.20779 = __builtin_expect (D.20778, 0);
  if (D.20779 != 0) goto <D.20780>; else goto <D.20781>;
  <D.20780>:
  if (0 != 0) goto <D.20782>; else goto <D.20783>;
  <D.20782>:
  monoeg_g_log (0B, 4, "pinned object %p has no gc descriptor", obj);
  <D.20231>:
  goto <D.20231>;
  <D.20783>:
  if (0 != 0) goto <D.20784>; else goto <D.20785>;
  <D.20784>:
  gc_debug_file.11 = gc_debug_file;
  fprintf (gc_debug_file.11, " (pinned, no change)\n");
  gc_debug_file.11 = gc_debug_file;
  fflush (gc_debug_file.11);
  <D.20785>:
  D.20786 = sgen_ptr_in_nursery (obj_slot);
  if (D.20786 == 0) goto <D.20787>; else goto <D.20788>;
  <D.20787>:
  sgen_add_to_global_remset (obj_slot, obj);
  <D.20788>:
  return;
  <D.20781>:
  copy = copy_object_no_checks (obj, queue);
  *obj_slot = copy;
  D.20789 = obj == copy;
  D.20790 = (long int) D.20789;
  D.20791 = __builtin_expect (D.20790, 0);
  if (D.20791 != 0) goto <D.20792>; else goto <D.20793>;
  <D.20792>:
  D.20797 = sgen_ptr_in_nursery (copy);
  if (D.20797 != 0) goto <D.20798>; else goto <D.20795>;
  <D.20798>:
  D.20799 = sgen_ptr_in_nursery (obj_slot);
  if (D.20799 == 0) goto <D.20800>; else goto <D.20795>;
  <D.20800>:
  iftmp.13 = 1;
  goto <D.20796>;
  <D.20795>:
  iftmp.13 = 0;
  <D.20796>:
  D.20801 = iftmp.13 != 0;
  D.20802 = (long int) D.20801;
  D.20803 = __builtin_expect (D.20802, 0);
  if (D.20803 != 0) goto <D.20804>; else goto <D.20805>;
  <D.20804>:
  sgen_add_to_global_remset (obj_slot, copy);
  <D.20805>:
  <D.20793>:
}


copy_object_no_checks (void * obj, struct SgenGrayQueue * queue)
{
  void * D.20807;
  unsigned int D.20808;
  unsigned int D.20809;
  unsigned int D.20810;
  _Bool D.20811;
  long int D.20812;
  long int D.20813;
  void * D.20816;
  struct SgenGrayQueue * iftmp.14;
  unsigned int destination.15;
  unsigned int D.20822;
  struct MonoVTable * vt;
  gboolean has_references;
  mword objsize;
  char * destination;

  vt = MEM[(struct MonoObject *)obj].vtable;
  D.20807 = vt->gc_descr;
  D.20808 = (unsigned int) D.20807;
  has_references = sgen_gc_descr_has_references (D.20808);
  D.20809 = sgen_par_object_get_size (vt, obj);
  D.20810 = D.20809 + 7;
  objsize = D.20810 & 4294967288;
  destination = alloc_for_promotion (vt, obj, objsize, has_references);
  D.20811 = destination == 0B;
  D.20812 = (long int) D.20811;
  D.20813 = __builtin_expect (D.20812, 0);
  if (D.20813 != 0) goto <D.20814>; else goto <D.20815>;
  <D.20814>:
  sgen_pin_object (obj, queue);
  sgen_set_pinned_from_failed_allocation (objsize);
  D.20816 = obj;
  return D.20816;
  <D.20815>:
  if (has_references != 0) goto <D.20818>; else goto <D.20819>;
  <D.20818>:
  iftmp.14 = queue;
  goto <D.20820>;
  <D.20819>:
  iftmp.14 = 0B;
  <D.20820>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.14);
  destination.15 = (unsigned int) destination;
  D.20822 = destination.15 | 1;
  MEM[(mword *)obj] = D.20822;
  D.20816 = destination;
  return D.20816;
}


sgen_gc_descr_has_references (mword desc)
{
  unsigned int D.20824;
  gboolean D.20827;
  unsigned int D.20828;
  unsigned int D.20831;

  D.20824 = desc & 4294901767;
  if (D.20824 == 1) goto <D.20825>; else goto <D.20826>;
  <D.20825>:
  D.20827 = 0;
  return D.20827;
  <D.20826>:
  D.20828 = desc & 49159;
  if (D.20828 == 4) goto <D.20829>; else goto <D.20830>;
  <D.20829>:
  D.20827 = 0;
  return D.20827;
  <D.20830>:
  D.20831 = desc & 7;
  if (D.20831 == 7) goto <D.20832>; else goto <D.20833>;
  <D.20832>:
  D.20827 = 0;
  return D.20827;
  <D.20833>:
  D.20827 = 1;
  return D.20827;
}


sgen_par_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  void * D.20835;
  unsigned int D.20836;
  guint D.20841;
  int D.20842;
  int D.20843;
  unsigned int D.20844;
  unsigned int D.20847;
  int D.20848;
  unsigned int D.20849;
  unsigned int element_size.16;
  unsigned int D.20851;
  unsigned int D.20852;
  struct MonoClass * D.20855;
  unsigned char D.20856;
  unsigned int D.20857;
  unsigned int D.20858;
  mword descr;
  mword type;

  D.20835 = vtable->gc_descr;
  descr = (mword) D.20835;
  type = descr & 7;
  D.20836 = type + 4294967295;
  if (D.20836 <= 1) goto <D.20837>; else goto <D.20838>;
  <D.20837>:
  {
    mword size;

    size = descr & 65528;
    if (size == 0) goto <D.20839>; else goto <D.20840>;
    <D.20839>:
    D.20842 = MEM[(struct MonoString *)o].length;
    D.20843 = D.20842 * 2;
    D.20844 = (unsigned int) D.20843;
    D.20841 = D.20844 + 14;
    return D.20841;
    <D.20840>:
    D.20841 = size;
    return D.20841;
  }
  <D.20838>:
  if (type == 4) goto <D.20845>; else goto <D.20846>;
  <D.20845>:
  {
    int element_size;
    struct MonoArray * array;
    size_t size;

    D.20847 = descr >> 3;
    D.20848 = (int) D.20847;
    element_size = D.20848 & 1023;
    array = o;
    D.20849 = array->max_length;
    element_size.16 = (unsigned int) element_size;
    D.20851 = D.20849 * element_size.16;
    size = D.20851 + 16;
    D.20852 = descr & 8192;
    if (D.20852 != 0) goto <D.20853>; else goto <D.20854>;
    <D.20853>:
    size = size + 3;
    size = size & 4294967292;
    D.20855 = vtable->klass;
    D.20856 = D.20855->rank;
    D.20857 = (unsigned int) D.20856;
    D.20858 = D.20857 * 8;
    size = D.20858 + size;
    <D.20854>:
    D.20841 = size;
    return D.20841;
  }
  <D.20846>:
  D.20841 = slow_object_get_size (vtable, o);
  return D.20841;
}


slow_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  struct MonoClass * D.20860;
  guint D.20863;
  int D.20864;
  int D.20865;
  unsigned int D.20866;
  unsigned char D.20867;
  int D.20870;
  unsigned int D.20871;
  unsigned int D.20872;
  unsigned int D.20873;
  struct MonoArrayBounds * D.20874;
  _Bool D.20875;
  long int D.20876;
  long int D.20877;
  unsigned int D.20880;
  unsigned int D.20881;
  int D.20882;
  struct MonoClass * klass;

  klass = vtable->klass;
  D.20860 = mono_defaults.string_class;
  if (D.20860 == klass) goto <D.20861>; else goto <D.20862>;
  <D.20861>:
  D.20864 = MEM[(struct MonoString *)o].length;
  D.20865 = D.20864 * 2;
  D.20866 = (unsigned int) D.20865;
  D.20863 = D.20866 + 14;
  return D.20863;
  <D.20862>:
  D.20867 = klass->rank;
  if (D.20867 != 0) goto <D.20868>; else goto <D.20869>;
  <D.20868>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.20870 = klass->sizes.element_size;
    D.20871 = (unsigned int) D.20870;
    D.20872 = array->max_length;
    D.20873 = D.20871 * D.20872;
    size = D.20873 + 16;
    D.20874 = array->bounds;
    D.20875 = D.20874 != 0B;
    D.20876 = (long int) D.20875;
    D.20877 = __builtin_expect (D.20876, 0);
    if (D.20877 != 0) goto <D.20878>; else goto <D.20879>;
    <D.20878>:
    size = size + 3;
    size = size & 4294967292;
    D.20867 = klass->rank;
    D.20880 = (unsigned int) D.20867;
    D.20881 = D.20880 * 8;
    size = D.20881 + size;
    <D.20879>:
    D.20863 = size;
    return D.20863;
  }
  <D.20869>:
  D.20882 = klass->instance_size;
  D.20863 = (guint) D.20882;
  return D.20863;
}


par_copy_object_no_checks (char * destination, struct MonoVTable * vt, void * obj, mword objsize, struct SgenGrayQueue * queue)
{
  struct MonoClass * D.20886;
  const char * D.20887;
  const char * D.20888;
  struct FILE * gc_debug_file.17;
  struct MonoVTable * D.20892;
  struct MonoClass * D.20893;
  const char * D.20894;
  unsigned int D.20897;
  const void * D.20898;
  mword * D.20899;
  unsigned int D.20900;
  mword * D.20901;
  unsigned int D.20902;
  mword * D.20903;
  unsigned int D.20904;
  mword * D.20905;
  unsigned int D.20906;
  mword * D.20907;
  unsigned int D.20908;
  mword * D.20909;
  unsigned int D.20910;
  mword * D.20911;
  unsigned int D.20912;
  void * D.20914;
  const void * D.20915;
  unsigned int D.20916;
  int iftmp.18;
  unsigned char D.20922;
  struct MonoArrayBounds * D.20924;
  _Bool D.20926;
  long int D.20927;
  long int D.20928;
  int D.20931;
  int obj.19;
  int D.20933;
  sizetype D.20934;
  struct MonoArrayBounds * D.20935;
  int D.20938;
  unsigned int D.20939;
  <unnamed type> mono_profiler_events.20;
  unsigned int D.20941;
  _Bool D.20942;
  long int D.20943;
  long int D.20944;
  const char * D.20951;
  int iftmp.21;
  struct GrayQueueSection * D.20956;
  int D.20958;
  _Bool D.20959;
  long int D.20960;
  long int D.20961;
  int D.20965;
  int D.20966;
  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.20884>; else goto <D.20885>;
  <D.20884>:
  D.20886 = vt->klass;
  D.20887 = D.20886->name_space;
  D.20886 = vt->klass;
  D.20888 = D.20886->name;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s was not initialized", vt, D.20887, D.20888);
  <D.20201>:
  goto <D.20201>;
  <D.20885>:
  if (0 != 0) goto <D.20889>; else goto <D.20890>;
  <D.20889>:
  gc_debug_file.17 = gc_debug_file;
  D.20892 = MEM[(struct MonoObject *)obj].vtable;
  D.20893 = D.20892->klass;
  D.20894 = D.20893->name;
  fprintf (gc_debug_file.17, " (to %p, %s size: %lu)\n", destination, D.20894, objsize);
  gc_debug_file.17 = gc_debug_file;
  fflush (gc_debug_file.17);
  <D.20890>:
  if (objsize <= 32) goto <D.20895>; else goto <D.20896>;
  <D.20895>:
  {
    mword * dest;

    dest = destination;
    D.20897 = objsize / 4;
    D.20898 = copy_labels[D.20897];
    goto D.20898;
    LAB_8:
    D.20899 = dest + 28;
    D.20900 = MEM[(mword *)obj + 28B];
    *D.20899 = D.20900;
    LAB_7:
    D.20901 = dest + 24;
    D.20902 = MEM[(mword *)obj + 24B];
    *D.20901 = D.20902;
    LAB_6:
    D.20903 = dest + 20;
    D.20904 = MEM[(mword *)obj + 20B];
    *D.20903 = D.20904;
    LAB_5:
    D.20905 = dest + 16;
    D.20906 = MEM[(mword *)obj + 16B];
    *D.20905 = D.20906;
    LAB_4:
    D.20907 = dest + 12;
    D.20908 = MEM[(mword *)obj + 12B];
    *D.20907 = D.20908;
    LAB_3:
    D.20909 = dest + 8;
    D.20910 = MEM[(mword *)obj + 8B];
    *D.20909 = D.20910;
    LAB_2:
    D.20911 = dest + 4;
    D.20912 = MEM[(mword *)obj + 4B];
    *D.20911 = D.20912;
    LAB_1:
    LAB_0:
  }
  goto <D.20913>;
  <D.20896>:
  D.20914 = destination + 4;
  D.20915 = obj + 4;
  D.20916 = objsize + 4294967292;
  mono_gc_memmove_aligned (D.20914, D.20915, D.20916);
  <D.20913>:
  if (0 != 0) goto <D.20917>; else goto <D.20918>;
  <D.20917>:
  D.20886 = vt->klass;
  D.20887 = D.20886->name_space;
  D.20886 = vt->klass;
  D.20888 = D.20886->name;
  monoeg_g_log (0B, 4, "vtable %p for class %s:%s has no gc descriptor", vt, D.20887, D.20888);
  <D.20203>:
  goto <D.20203>;
  <D.20918>:
  D.20922 = vt->rank;
  if (D.20922 != 0) goto <D.20923>; else goto <D.20920>;
  <D.20923>:
  D.20924 = MEM[(struct MonoArray *)obj].bounds;
  if (D.20924 != 0B) goto <D.20925>; else goto <D.20920>;
  <D.20925>:
  iftmp.18 = 1;
  goto <D.20921>;
  <D.20920>:
  iftmp.18 = 0;
  <D.20921>:
  D.20926 = iftmp.18 != 0;
  D.20927 = (long int) D.20926;
  D.20928 = __builtin_expect (D.20927, 0);
  if (D.20928 != 0) goto <D.20929>; else goto <D.20930>;
  <D.20929>:
  {
    struct MonoArray * array;

    array = destination;
    D.20924 = MEM[(struct MonoArray *)obj].bounds;
    D.20931 = (int) D.20924;
    obj.19 = (int) obj;
    D.20933 = D.20931 - obj.19;
    D.20934 = (sizetype) D.20933;
    D.20935 = destination + D.20934;
    array->bounds = D.20935;
    if (0 != 0) goto <D.20936>; else goto <D.20937>;
    <D.20936>:
    gc_debug_file.17 = gc_debug_file;
    D.20922 = vt->rank;
    D.20938 = (int) D.20922;
    D.20939 = mono_array_length (array);
    fprintf (gc_debug_file.17, "Array instance %p: size: %lu, rank: %d, length: %lu\n", array, objsize, D.20938, D.20939);
    gc_debug_file.17 = gc_debug_file;
    fflush (gc_debug_file.17);
    <D.20937>:
  }
  <D.20930>:
  mono_profiler_events.20 = mono_profiler_events;
  D.20941 = mono_profiler_events.20 & 524288;
  D.20942 = D.20941 != 0;
  D.20943 = (long int) D.20942;
  D.20944 = __builtin_expect (D.20943, 0);
  if (D.20944 != 0) goto <D.20945>; else goto <D.20946>;
  <D.20945>:
  sgen_register_moved_object (obj, destination);
  <D.20946>:
  obj = destination;
  if (queue != 0B) goto <D.20947>; else goto <D.20948>;
  <D.20947>:
  if (0 != 0) goto <D.20949>; else goto <D.20950>;
  <D.20949>:
  gc_debug_file.17 = gc_debug_file;
  D.20951 = sgen_safe_name (obj);
  fprintf (gc_debug_file.17, "Enqueuing gray object %p (%s)\n", obj, D.20951);
  gc_debug_file.17 = gc_debug_file;
  fflush (gc_debug_file.17);
  <D.20950>:
  D.20956 = queue->first;
  if (D.20956 == 0B) goto <D.20953>; else goto <D.20957>;
  <D.20957>:
  D.20956 = queue->first;
  D.20958 = D.20956->end;
  if (D.20958 == 125) goto <D.20953>; else goto <D.20954>;
  <D.20953>:
  iftmp.21 = 1;
  goto <D.20955>;
  <D.20954>:
  iftmp.21 = 0;
  <D.20955>:
  D.20959 = iftmp.21 != 0;
  D.20960 = (long int) D.20959;
  D.20961 = __builtin_expect (D.20960, 0);
  if (D.20961 != 0) goto <D.20962>; else goto <D.20963>;
  <D.20962>:
  sgen_gray_object_enqueue (queue, obj);
  goto <D.20964>;
  <D.20963>:
  D.20956 = queue->first;
  D.20956 = queue->first;
  D.20958 = D.20956->end;
  D.20965 = D.20958;
  D.20966 = D.20965 + 1;
  D.20956->end = D.20966;
  D.20956->objects[D.20965] = obj;
  <D.20964>:
  __builtin_prefetch (obj);
  <D.20948>:
}


sgen_ptr_in_nursery (void * p)
{
  gboolean D.20969;
  int sgen_nursery_bits.23;
  int D.20971;
  int D.20972;
  unsigned int D.20973;
  unsigned int p.24;
  unsigned int D.20975;
  char * sgen_nursery_start.25;
  unsigned int sgen_nursery_start.26;
  _Bool D.20978;

  sgen_nursery_bits.23 = sgen_nursery_bits;
  D.20971 = 1 << sgen_nursery_bits.23;
  D.20972 = -D.20971;
  D.20973 = (unsigned int) D.20972;
  p.24 = (unsigned int) p;
  D.20975 = D.20973 & p.24;
  sgen_nursery_start.25 = sgen_nursery_start;
  sgen_nursery_start.26 = (unsigned int) sgen_nursery_start.25;
  D.20978 = D.20975 == sgen_nursery_start.26;
  D.20969 = (gboolean) D.20978;
  return D.20969;
}


simple_nursery_serial_scan_object (char * start, struct SgenGrayQueue * queue)
{
  unsigned int D.20980;
  unsigned int D.20981;
  unsigned int D.20982;
  unsigned int D.20983;
  unsigned int D.20986;
  unsigned int D.20987;
  unsigned int D.20988;
  unsigned int D.20989;
  unsigned int D.20990;
  void * D.20995;
  struct FILE * gc_debug_file.27;
  unsigned int _index.28;
  unsigned int D.21006;
  int D.21007;
  void * D.21012;
  unsigned int _index.29;
  unsigned int D.21016;
  int D.21017;
  unsigned int D.21024;
  unsigned int D.21027;
  int D.21028;
  int desc.30;
  unsigned int D.21032;
  unsigned int el_size.31;
  unsigned int D.21034;
  void * D.21039;
  int D.21045;
  unsigned int offset.32;
  unsigned int D.21047;
  unsigned int i.33;
  unsigned int D.21049;
  void * * D.21050;
  void * D.21055;
  sizetype el_size.34;
  unsigned int D.21062;
  void * D.21069;
  unsigned int D.21072;
  void * D.21079;
  unsigned int D.21082;
  unsigned int D.21083;
  struct MonoVTable * D.21086;
  struct MonoClass * D.21087;
  const char * D.21088;
  const char * D.21089;
  gsize * bitmap_data.35;
  unsigned int D.21091;
  void * D.21098;
  int bwords.36;
  unsigned int D.21102;
  gsize * mbitmap_data.37;
  unsigned int D.21104;
  unsigned int D.21105;
  struct MonoClass * D.21106;
  unsigned int el_size.38;
  unsigned int D.21108;
  const char * D.21111;
  const char * D.21112;
  gsize * bitmap_data.39;
  unsigned int D.21114;
  void * D.21121;
  unsigned int bwords.40;
  sizetype el_size.41;

  {
    struct GCVTable * vt;
    mword desc;

    D.20980 = MEM[(mword *)start];
    D.20981 = D.20980 & 4294967292;
    vt = (struct GCVTable *) D.20981;
    desc = vt->desc;
    D.20982 = desc & 7;
    switch (D.20982) <default: <D.20546>, case 1: <D.20451>, case 2: <D.20460>, case 3: <D.20510>, case 4: <D.20470>, case 5: <D.20503>, case 6: <D.20524>, case 7: <D.20545>>
    <D.20451>:
    D.20983 = desc & 4294901760;
    if (D.20983 != 0) goto <D.20984>; else goto <D.20985>;
    <D.20984>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.20986 = desc >> 16;
      D.20987 = D.20986 & 255;
      D.20988 = D.20987 * 4;
      _objptr = _objptr + D.20988;
      D.20989 = desc >> 24;
      D.20990 = D.20989 * 4;
      _objptr_end = _objptr + D.20990;
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.20991>; else goto <D.20992>;
        <D.20991>:
        simple_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.20993>; else goto <D.20994>;
        <D.20993>:
        D.20995 = *_objptr;
        if (D.20995 != __old) goto <D.20996>; else goto <D.20997>;
        <D.20996>:
        gc_debug_file.27 = gc_debug_file;
        D.20995 = *_objptr;
        fprintf (gc_debug_file.27, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20995, __old);
        gc_debug_file.27 = gc_debug_file;
        fflush (gc_debug_file.27);
        <D.20997>:
        <D.20994>:
        <D.20992>:
      }
      _objptr = _objptr + 4;
      goto <D.20457>;
      <D.20456>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.20999>; else goto <D.21000>;
        <D.20999>:
        simple_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.21001>; else goto <D.21002>;
        <D.21001>:
        D.20995 = *_objptr;
        if (D.20995 != __old) goto <D.21003>; else goto <D.21004>;
        <D.21003>:
        gc_debug_file.27 = gc_debug_file;
        D.20995 = *_objptr;
        fprintf (gc_debug_file.27, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.20995, __old);
        gc_debug_file.27 = gc_debug_file;
        fflush (gc_debug_file.27);
        <D.21004>:
        <D.21002>:
        <D.21000>:
      }
      _objptr = _objptr + 4;
      <D.20457>:
      if (_objptr < _objptr_end) goto <D.20456>; else goto <D.20458>;
      <D.20458>:
    }
    <D.20985>:
    goto <D.20459>;
    <D.20460>:
    {
      void * * _objptr;
      gsize _bmap;

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

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

          __old = *_objptr;
          if (__old != 0B) goto <D.21008>; else goto <D.21009>;
          <D.21008>:
          simple_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.21010>; else goto <D.21011>;
          <D.21010>:
          D.21012 = *_objptr;
          if (D.21012 != __old) goto <D.21013>; else goto <D.21014>;
          <D.21013>:
          gc_debug_file.27 = gc_debug_file;
          D.21012 = *_objptr;
          fprintf (gc_debug_file.27, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21012, __old);
          gc_debug_file.27 = gc_debug_file;
          fflush (gc_debug_file.27);
          <D.21014>:
          <D.21011>:
          <D.21009>:
        }
        _objptr = _objptr + 4;
      }
      goto <D.20468>;
      <D.20467>:
      {
        int _index;

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

          __old = *_objptr;
          if (__old != 0B) goto <D.21018>; else goto <D.21019>;
          <D.21018>:
          simple_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.21020>; else goto <D.21021>;
          <D.21020>:
          D.21012 = *_objptr;
          if (D.21012 != __old) goto <D.21022>; else goto <D.21023>;
          <D.21022>:
          gc_debug_file.27 = gc_debug_file;
          D.21012 = *_objptr;
          fprintf (gc_debug_file.27, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21012, __old);
          gc_debug_file.27 = gc_debug_file;
          fflush (gc_debug_file.27);
          <D.21023>:
          <D.21021>:
          <D.21019>:
        }
        _objptr = _objptr + 4;
      }
      <D.20468>:
      if (_bmap != 0) goto <D.20467>; else goto <D.20469>;
      <D.20469>:
    }
    goto <D.20459>;
    <D.20470>:
    D.21024 = desc & 4294950912;
    if (D.21024 != 0) goto <D.21025>; else goto <D.21026>;
    <D.21025>:
    {
      int el_size;
      int etype;

      D.21027 = desc >> 3;
      D.21028 = (int) D.21027;
      el_size = D.21028 & 1023;
      desc.30 = (int) desc;
      etype = desc.30 & 49152;
      if (etype == 16384) goto <D.21030>; else goto <D.21031>;
      <D.21030>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.21032 = MEM[(struct MonoArray *)start].max_length;
        el_size.31 = (unsigned int) el_size;
        D.21034 = D.21032 * el_size.31;
        end_refs = p + D.21034;
        goto <D.20477>;
        <D.20476>:
        {
          void * __old;

          __old = *p;
          if (__old != 0B) goto <D.21035>; else goto <D.21036>;
          <D.21035>:
          simple_nursery_serial_copy_object_from_obj (p, queue);
          if (0 != 0) goto <D.21037>; else goto <D.21038>;
          <D.21037>:
          D.21039 = *p;
          if (D.21039 != __old) goto <D.21040>; else goto <D.21041>;
          <D.21040>:
          gc_debug_file.27 = gc_debug_file;
          D.21039 = *p;
          fprintf (gc_debug_file.27, "Overwrote field at %p with %p (was: %p)\n", p, D.21039, __old);
          gc_debug_file.27 = gc_debug_file;
          fflush (gc_debug_file.27);
          <D.21041>:
          <D.21038>:
          <D.21036>:
        }
        p = p + 4;
        <D.20477>:
        if (p < end_refs) goto <D.20476>; else goto <D.20478>;
        <D.20478>:
      }
      goto <D.21042>;
      <D.21031>:
      if (etype == 32768) goto <D.21043>; else goto <D.21044>;
      <D.21043>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.20986 = desc >> 16;
        D.21045 = (int) D.20986;
        offset = D.21045 & 255;
        D.20989 = desc >> 24;
        num_refs = (int) D.20989;
        e_start = start + 16;
        D.21032 = MEM[(struct MonoArray *)start].max_length;
        el_size.31 = (unsigned int) el_size;
        D.21034 = D.21032 * el_size.31;
        e_end = e_start + D.21034;
        goto <D.20490>;
        <D.20489>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.32 = (unsigned int) offset;
          D.21047 = offset.32 * 4;
          p = p + D.21047;
          i = 0;
          goto <D.20487>;
          <D.20486>:
          {
            void * __old;

            i.33 = (unsigned int) i;
            D.21049 = i.33 * 4;
            D.21050 = p + D.21049;
            __old = *D.21050;
            if (__old != 0B) goto <D.21051>; else goto <D.21052>;
            <D.21051>:
            i.33 = (unsigned int) i;
            D.21049 = i.33 * 4;
            D.21050 = p + D.21049;
            simple_nursery_serial_copy_object_from_obj (D.21050, queue);
            if (0 != 0) goto <D.21053>; else goto <D.21054>;
            <D.21053>:
            i.33 = (unsigned int) i;
            D.21049 = i.33 * 4;
            D.21050 = p + D.21049;
            D.21055 = *D.21050;
            if (D.21055 != __old) goto <D.21056>; else goto <D.21057>;
            <D.21056>:
            gc_debug_file.27 = gc_debug_file;
            i.33 = (unsigned int) i;
            D.21049 = i.33 * 4;
            D.21050 = p + D.21049;
            i.33 = (unsigned int) i;
            D.21049 = i.33 * 4;
            D.21050 = p + D.21049;
            D.21055 = *D.21050;
            fprintf (gc_debug_file.27, "Overwrote field at %p with %p (was: %p)\n", D.21050, D.21055, __old);
            gc_debug_file.27 = gc_debug_file;
            fflush (gc_debug_file.27);
            <D.21057>:
            <D.21054>:
            <D.21052>:
          }
          i = i + 1;
          <D.20487>:
          if (i < num_refs) goto <D.20486>; else goto <D.20488>;
          <D.20488>:
          el_size.34 = (sizetype) el_size;
          e_start = e_start + el_size.34;
        }
        <D.20490>:
        if (e_start < e_end) goto <D.20489>; else goto <D.20491>;
        <D.20491>:
      }
      goto <D.21059>;
      <D.21044>:
      if (etype == 49152) goto <D.21060>; else goto <D.21061>;
      <D.21060>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.21032 = MEM[(struct MonoArray *)start].max_length;
        el_size.31 = (unsigned int) el_size;
        D.21034 = D.21032 * el_size.31;
        e_end = e_start + D.21034;
        goto <D.20501>;
        <D.20500>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.20498>;
          <D.20497>:
          D.21062 = _bmap & 1;
          if (D.21062 != 0) goto <D.21063>; else goto <D.21064>;
          <D.21063>:
          {
            void * __old;

            __old = *p;
            if (__old != 0B) goto <D.21065>; else goto <D.21066>;
            <D.21065>:
            simple_nursery_serial_copy_object_from_obj (p, queue);
            if (0 != 0) goto <D.21067>; else goto <D.21068>;
            <D.21067>:
            D.21069 = *p;
            if (D.21069 != __old) goto <D.21070>; else goto <D.21071>;
            <D.21070>:
            gc_debug_file.27 = gc_debug_file;
            D.21069 = *p;
            fprintf (gc_debug_file.27, "Overwrote field at %p with %p (was: %p)\n", p, D.21069, __old);
            gc_debug_file.27 = gc_debug_file;
            fflush (gc_debug_file.27);
            <D.21071>:
            <D.21068>:
            <D.21066>:
          }
          <D.21064>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.20498>:
          if (_bmap != 0) goto <D.20497>; else goto <D.20499>;
          <D.20499>:
          el_size.34 = (sizetype) el_size;
          e_start = e_start + el_size.34;
        }
        <D.20501>:
        if (e_start < e_end) goto <D.20500>; else goto <D.20502>;
        <D.20502>:
      }
      <D.21061>:
      <D.21059>:
      <D.21042>:
    }
    <D.21026>:
    goto <D.20459>;
    <D.20503>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.20508>;
      <D.20507>:
      D.21072 = _bmap & 1;
      if (D.21072 != 0) goto <D.21073>; else goto <D.21074>;
      <D.21073>:
      {
        void * __old;

        __old = *_objptr;
        if (__old != 0B) goto <D.21075>; else goto <D.21076>;
        <D.21075>:
        simple_nursery_serial_copy_object_from_obj (_objptr, queue);
        if (0 != 0) goto <D.21077>; else goto <D.21078>;
        <D.21077>:
        D.21079 = *_objptr;
        if (D.21079 != __old) goto <D.21080>; else goto <D.21081>;
        <D.21080>:
        gc_debug_file.27 = gc_debug_file;
        D.21079 = *_objptr;
        fprintf (gc_debug_file.27, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21079, __old);
        gc_debug_file.27 = gc_debug_file;
        fflush (gc_debug_file.27);
        <D.21081>:
        <D.21078>:
        <D.21076>:
      }
      <D.21074>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20508>:
      if (_bmap != 0) goto <D.20507>; else goto <D.20509>;
      <D.20509>:
    }
    goto <D.20459>;
    <D.20510>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.21082 = *bitmap_data;
      D.21083 = D.21082 + 4294967295;
      bwords = (int) D.21083;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.21084>; else goto <D.21085>;
      <D.21084>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.21086 = myobj->vtable;
        D.21087 = D.21086->klass;
        D.21088 = D.21087->name_space;
        D.21086 = myobj->vtable;
        D.21087 = D.21086->klass;
        D.21089 = D.21087->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21088, D.21089);
      }
      <D.21085>:
      goto <D.20522>;
      <D.20521>:
      {
        gsize _bmap;

        bitmap_data.35 = bitmap_data;
        bitmap_data = bitmap_data.35 + 4;
        _bmap = *bitmap_data.35;
        _objptr = start_run;
        goto <D.20519>;
        <D.20518>:
        D.21091 = _bmap & 1;
        if (D.21091 != 0) goto <D.21092>; else goto <D.21093>;
        <D.21092>:
        {
          void * __old;

          __old = *_objptr;
          if (__old != 0B) goto <D.21094>; else goto <D.21095>;
          <D.21094>:
          simple_nursery_serial_copy_object_from_obj (_objptr, queue);
          if (0 != 0) goto <D.21096>; else goto <D.21097>;
          <D.21096>:
          D.21098 = *_objptr;
          if (D.21098 != __old) goto <D.21099>; else goto <D.21100>;
          <D.21099>:
          gc_debug_file.27 = gc_debug_file;
          D.21098 = *_objptr;
          fprintf (gc_debug_file.27, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21098, __old);
          gc_debug_file.27 = gc_debug_file;
          fflush (gc_debug_file.27);
          <D.21100>:
          <D.21097>:
          <D.21095>:
        }
        <D.21093>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.20519>:
        if (_bmap != 0) goto <D.20518>; else goto <D.20520>;
        <D.20520>:
        start_run = start_run + 128;
      }
      <D.20522>:
      bwords.36 = bwords;
      bwords = bwords.36 + -1;
      if (bwords.36 > 0) goto <D.20521>; else goto <D.20523>;
      <D.20523>:
    }
    goto <D.20459>;
    <D.20524>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.21102 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.21102);
      mbitmap_data.37 = mbitmap_data;
      mbitmap_data = mbitmap_data.37 + 4;
      D.21104 = *mbitmap_data.37;
      D.21105 = D.21104 + 4294967295;
      mbwords = (int) D.21105;
      D.21106 = vt->klass;
      el_size = mono_array_element_size (D.21106);
      e_start = start + 16;
      D.21032 = MEM[(struct MonoArray *)start].max_length;
      el_size.38 = (unsigned int) el_size;
      D.21108 = D.21032 * el_size.38;
      e_end = e_start + D.21108;
      if (0 != 0) goto <D.21109>; else goto <D.21110>;
      <D.21109>:
      D.21102 = vt->desc;
      D.21106 = vt->klass;
      D.21111 = D.21106->name_space;
      D.21106 = vt->klass;
      D.21112 = D.21106->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.21102, D.21111, D.21112);
      <D.21110>:
      goto <D.20543>;
      <D.20542>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.39 = bitmap_data;
          bitmap_data = bitmap_data.39 + 4;
          _bmap = *bitmap_data.39;
          start_run = _objptr;
          goto <D.20537>;
          <D.20536>:
          D.21114 = _bmap & 1;
          if (D.21114 != 0) goto <D.21115>; else goto <D.21116>;
          <D.21115>:
          {
            void * __old;

            __old = *_objptr;
            if (__old != 0B) goto <D.21117>; else goto <D.21118>;
            <D.21117>:
            simple_nursery_serial_copy_object_from_obj (_objptr, queue);
            if (0 != 0) goto <D.21119>; else goto <D.21120>;
            <D.21119>:
            D.21121 = *_objptr;
            if (D.21121 != __old) goto <D.21122>; else goto <D.21123>;
            <D.21122>:
            gc_debug_file.27 = gc_debug_file;
            D.21121 = *_objptr;
            fprintf (gc_debug_file.27, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21121, __old);
            gc_debug_file.27 = gc_debug_file;
            fflush (gc_debug_file.27);
            <D.21123>:
            <D.21120>:
            <D.21118>:
          }
          <D.21116>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.20537>:
          if (_bmap != 0) goto <D.20536>; else goto <D.20538>;
          <D.20538>:
          _objptr = start_run + 128;
        }
        <D.20540>:
        bwords.40 = bwords;
        bwords = bwords.40 + 4294967295;
        if (bwords.40 != 0) goto <D.20539>; else goto <D.20541>;
        <D.20541>:
        el_size.41 = (sizetype) el_size;
        e_start = e_start + el_size.41;
      }
      <D.20543>:
      if (e_start < e_end) goto <D.20542>; else goto <D.20544>;
      <D.20544>:
    }
    goto <D.20459>;
    <D.20545>:
    goto <D.20459>;
    <D.20546>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.20459>:
  }
}


simple_nursery_parallel_scan_vtype (char * start, mword desc, struct SgenGrayQueue * queue)
{
  unsigned int D.21127;
  unsigned int D.21128;
  unsigned int D.21131;
  unsigned int D.21132;
  unsigned int D.21133;
  unsigned int D.21134;
  unsigned int D.21135;
  struct FILE * gc_debug_file.42;
  void * D.21143;
  int iftmp.43;
  int D.21147;
  int D.21149;
  _Bool D.21151;
  long int D.21152;
  long int D.21153;
  int iftmp.44;
  int D.21165;
  int D.21167;
  _Bool D.21169;
  long int D.21170;
  long int D.21171;
  unsigned int _index.45;
  unsigned int D.21175;
  int D.21176;
  void * D.21183;
  int iftmp.46;
  int D.21187;
  int D.21189;
  _Bool D.21191;
  long int D.21192;
  long int D.21193;
  unsigned int _index.47;
  unsigned int D.21197;
  int D.21198;
  int iftmp.48;
  int D.21208;
  int D.21210;
  _Bool D.21212;
  long int D.21213;
  long int D.21214;
  unsigned int D.21217;
  unsigned int D.21220;
  int D.21221;
  int desc.49;
  unsigned int D.21225;
  unsigned int el_size.50;
  unsigned int D.21227;
  void * D.21234;
  int iftmp.51;
  int D.21238;
  int D.21240;
  _Bool D.21242;
  long int D.21243;
  long int D.21244;
  int D.21250;
  unsigned int offset.52;
  unsigned int D.21252;
  unsigned int i.53;
  unsigned int D.21254;
  void * * D.21255;
  void * D.21262;
  int iftmp.54;
  int D.21266;
  void * D.21268;
  int D.21269;
  _Bool D.21271;
  long int D.21272;
  long int D.21273;
  void * D.21276;
  sizetype el_size.55;
  unsigned int D.21281;
  void * D.21290;
  int iftmp.56;
  int D.21294;
  int D.21296;
  _Bool D.21298;
  long int D.21299;
  long int D.21300;
  unsigned int D.21303;
  void * D.21312;
  int iftmp.57;
  int D.21316;
  int D.21318;
  _Bool D.21320;
  long int D.21321;
  long int D.21322;
  unsigned int D.21325;
  unsigned int D.21326;
  struct MonoVTable * D.21329;
  struct MonoClass * D.21330;
  const char * D.21331;
  const char * D.21332;
  gsize * bitmap_data.58;
  unsigned int D.21334;
  void * D.21343;
  int iftmp.59;
  int D.21347;
  int D.21349;
  _Bool D.21351;
  long int D.21352;
  long int D.21353;
  int bwords.60;

  start = start + 4294967288;
  D.21127 = desc & 7;
  switch (D.21127) <default: <D.20444>, case 1: <D.20361>, case 2: <D.20372>, case 3: <D.20428>, case 4: <D.20384>, case 5: <D.20420>, case 7: <D.20443>>
  <D.20361>:
  D.21128 = desc & 4294901760;
  if (D.21128 != 0) goto <D.21129>; else goto <D.21130>;
  <D.21129>:
  {
    void * * _objptr_end;
    void * * _objptr;

    _objptr = start;
    D.21131 = desc >> 16;
    D.21132 = D.21131 & 255;
    D.21133 = D.21132 * 4;
    _objptr = _objptr + D.21133;
    D.21134 = desc >> 24;
    D.21135 = D.21134 * 4;
    _objptr_end = _objptr + D.21135;
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.21136>; else goto <D.21137>;
      <D.21136>:
      simple_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.21138>; else goto <D.21139>;
      <D.21138>:
      if (__old != __copy) goto <D.21140>; else goto <D.21141>;
      <D.21140>:
      gc_debug_file.42 = gc_debug_file;
      D.21143 = *_objptr;
      fprintf (gc_debug_file.42, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21143, __old);
      gc_debug_file.42 = gc_debug_file;
      fflush (gc_debug_file.42);
      <D.21141>:
      <D.21139>:
      D.21147 = sgen_ptr_in_nursery (__copy);
      if (D.21147 != 0) goto <D.21148>; else goto <D.21145>;
      <D.21148>:
      D.21149 = sgen_ptr_in_nursery (_objptr);
      if (D.21149 == 0) goto <D.21150>; else goto <D.21145>;
      <D.21150>:
      iftmp.43 = 1;
      goto <D.21146>;
      <D.21145>:
      iftmp.43 = 0;
      <D.21146>:
      D.21151 = iftmp.43 != 0;
      D.21152 = (long int) D.21151;
      D.21153 = __builtin_expect (D.21152, 0);
      if (D.21153 != 0) goto <D.21154>; else goto <D.21155>;
      <D.21154>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.21155>:
      <D.21137>:
    }
    _objptr = _objptr + 4;
    goto <D.20369>;
    <D.20368>:
    {
      void * __old;
      void * __copy;

      __old = *_objptr;
      if (__old != 0B) goto <D.21156>; else goto <D.21157>;
      <D.21156>:
      simple_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.21158>; else goto <D.21159>;
      <D.21158>:
      if (__old != __copy) goto <D.21160>; else goto <D.21161>;
      <D.21160>:
      gc_debug_file.42 = gc_debug_file;
      D.21143 = *_objptr;
      fprintf (gc_debug_file.42, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21143, __old);
      gc_debug_file.42 = gc_debug_file;
      fflush (gc_debug_file.42);
      <D.21161>:
      <D.21159>:
      D.21165 = sgen_ptr_in_nursery (__copy);
      if (D.21165 != 0) goto <D.21166>; else goto <D.21163>;
      <D.21166>:
      D.21167 = sgen_ptr_in_nursery (_objptr);
      if (D.21167 == 0) goto <D.21168>; else goto <D.21163>;
      <D.21168>:
      iftmp.44 = 1;
      goto <D.21164>;
      <D.21163>:
      iftmp.44 = 0;
      <D.21164>:
      D.21169 = iftmp.44 != 0;
      D.21170 = (long int) D.21169;
      D.21171 = __builtin_expect (D.21170, 0);
      if (D.21171 != 0) goto <D.21172>; else goto <D.21173>;
      <D.21172>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.21173>:
      <D.21157>:
    }
    _objptr = _objptr + 4;
    <D.20369>:
    if (_objptr < _objptr_end) goto <D.20368>; else goto <D.20370>;
    <D.20370>:
  }
  <D.21130>:
  goto <D.20371>;
  <D.20372>:
  {
    void * * _objptr;
    gsize _bmap;

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

      _index = __builtin_ctz (_bmap);
      _index.45 = (unsigned int) _index;
      D.21175 = _index.45 * 4;
      _objptr = _objptr + D.21175;
      D.21176 = _index + 1;
      _bmap = _bmap >> D.21176;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21177>; else goto <D.21178>;
        <D.21177>:
        simple_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21179>; else goto <D.21180>;
        <D.21179>:
        if (__old != __copy) goto <D.21181>; else goto <D.21182>;
        <D.21181>:
        gc_debug_file.42 = gc_debug_file;
        D.21183 = *_objptr;
        fprintf (gc_debug_file.42, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21183, __old);
        gc_debug_file.42 = gc_debug_file;
        fflush (gc_debug_file.42);
        <D.21182>:
        <D.21180>:
        D.21187 = sgen_ptr_in_nursery (__copy);
        if (D.21187 != 0) goto <D.21188>; else goto <D.21185>;
        <D.21188>:
        D.21189 = sgen_ptr_in_nursery (_objptr);
        if (D.21189 == 0) goto <D.21190>; else goto <D.21185>;
        <D.21190>:
        iftmp.46 = 1;
        goto <D.21186>;
        <D.21185>:
        iftmp.46 = 0;
        <D.21186>:
        D.21191 = iftmp.46 != 0;
        D.21192 = (long int) D.21191;
        D.21193 = __builtin_expect (D.21192, 0);
        if (D.21193 != 0) goto <D.21194>; else goto <D.21195>;
        <D.21194>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21195>:
        <D.21178>:
      }
      _objptr = _objptr + 4;
    }
    goto <D.20382>;
    <D.20381>:
    {
      int _index;

      _index = __builtin_ctz (_bmap);
      _index.47 = (unsigned int) _index;
      D.21197 = _index.47 * 4;
      _objptr = _objptr + D.21197;
      D.21198 = _index + 1;
      _bmap = _bmap >> D.21198;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21199>; else goto <D.21200>;
        <D.21199>:
        simple_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21201>; else goto <D.21202>;
        <D.21201>:
        if (__old != __copy) goto <D.21203>; else goto <D.21204>;
        <D.21203>:
        gc_debug_file.42 = gc_debug_file;
        D.21183 = *_objptr;
        fprintf (gc_debug_file.42, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21183, __old);
        gc_debug_file.42 = gc_debug_file;
        fflush (gc_debug_file.42);
        <D.21204>:
        <D.21202>:
        D.21208 = sgen_ptr_in_nursery (__copy);
        if (D.21208 != 0) goto <D.21209>; else goto <D.21206>;
        <D.21209>:
        D.21210 = sgen_ptr_in_nursery (_objptr);
        if (D.21210 == 0) goto <D.21211>; else goto <D.21206>;
        <D.21211>:
        iftmp.48 = 1;
        goto <D.21207>;
        <D.21206>:
        iftmp.48 = 0;
        <D.21207>:
        D.21212 = iftmp.48 != 0;
        D.21213 = (long int) D.21212;
        D.21214 = __builtin_expect (D.21213, 0);
        if (D.21214 != 0) goto <D.21215>; else goto <D.21216>;
        <D.21215>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21216>:
        <D.21200>:
      }
      _objptr = _objptr + 4;
    }
    <D.20382>:
    if (_bmap != 0) goto <D.20381>; else goto <D.20383>;
    <D.20383>:
  }
  goto <D.20371>;
  <D.20384>:
  D.21217 = desc & 4294950912;
  if (D.21217 != 0) goto <D.21218>; else goto <D.21219>;
  <D.21218>:
  {
    int el_size;
    int etype;

    D.21220 = desc >> 3;
    D.21221 = (int) D.21220;
    el_size = D.21221 & 1023;
    desc.49 = (int) desc;
    etype = desc.49 & 49152;
    if (etype == 16384) goto <D.21223>; else goto <D.21224>;
    <D.21223>:
    {
      void * * p;
      void * * end_refs;

      p = start + 16;
      D.21225 = MEM[(struct MonoArray *)start].max_length;
      el_size.50 = (unsigned int) el_size;
      D.21227 = D.21225 * el_size.50;
      end_refs = p + D.21227;
      goto <D.20392>;
      <D.20391>:
      {
        void * __old;
        void * __copy;

        __old = *p;
        if (__old != 0B) goto <D.21228>; else goto <D.21229>;
        <D.21228>:
        simple_nursery_parallel_copy_object (p, queue);
        __copy = *p;
        if (0 != 0) goto <D.21230>; else goto <D.21231>;
        <D.21230>:
        if (__old != __copy) goto <D.21232>; else goto <D.21233>;
        <D.21232>:
        gc_debug_file.42 = gc_debug_file;
        D.21234 = *p;
        fprintf (gc_debug_file.42, "Overwrote field at %p with %p (was: %p)\n", p, D.21234, __old);
        gc_debug_file.42 = gc_debug_file;
        fflush (gc_debug_file.42);
        <D.21233>:
        <D.21231>:
        D.21238 = sgen_ptr_in_nursery (__copy);
        if (D.21238 != 0) goto <D.21239>; else goto <D.21236>;
        <D.21239>:
        D.21240 = sgen_ptr_in_nursery (p);
        if (D.21240 == 0) goto <D.21241>; else goto <D.21236>;
        <D.21241>:
        iftmp.51 = 1;
        goto <D.21237>;
        <D.21236>:
        iftmp.51 = 0;
        <D.21237>:
        D.21242 = iftmp.51 != 0;
        D.21243 = (long int) D.21242;
        D.21244 = __builtin_expect (D.21243, 0);
        if (D.21244 != 0) goto <D.21245>; else goto <D.21246>;
        <D.21245>:
        sgen_add_to_global_remset (p, __copy);
        <D.21246>:
        <D.21229>:
      }
      p = p + 4;
      <D.20392>:
      if (p < end_refs) goto <D.20391>; else goto <D.20393>;
      <D.20393>:
    }
    goto <D.21247>;
    <D.21224>:
    if (etype == 32768) goto <D.21248>; else goto <D.21249>;
    <D.21248>:
    {
      int offset;
      int num_refs;
      char * e_start;
      char * e_end;

      D.21131 = desc >> 16;
      D.21250 = (int) D.21131;
      offset = D.21250 & 255;
      D.21134 = desc >> 24;
      num_refs = (int) D.21134;
      e_start = start + 16;
      D.21225 = MEM[(struct MonoArray *)start].max_length;
      el_size.50 = (unsigned int) el_size;
      D.21227 = D.21225 * el_size.50;
      e_end = e_start + D.21227;
      goto <D.20406>;
      <D.20405>:
      {
        void * * p;
        int i;

        p = e_start;
        offset.52 = (unsigned int) offset;
        D.21252 = offset.52 * 4;
        p = p + D.21252;
        i = 0;
        goto <D.20403>;
        <D.20402>:
        {
          void * __old;
          void * __copy;

          i.53 = (unsigned int) i;
          D.21254 = i.53 * 4;
          D.21255 = p + D.21254;
          __old = *D.21255;
          if (__old != 0B) goto <D.21256>; else goto <D.21257>;
          <D.21256>:
          i.53 = (unsigned int) i;
          D.21254 = i.53 * 4;
          D.21255 = p + D.21254;
          simple_nursery_parallel_copy_object (D.21255, queue);
          i.53 = (unsigned int) i;
          D.21254 = i.53 * 4;
          D.21255 = p + D.21254;
          __copy = *D.21255;
          if (0 != 0) goto <D.21258>; else goto <D.21259>;
          <D.21258>:
          if (__old != __copy) goto <D.21260>; else goto <D.21261>;
          <D.21260>:
          gc_debug_file.42 = gc_debug_file;
          i.53 = (unsigned int) i;
          D.21254 = i.53 * 4;
          D.21255 = p + D.21254;
          i.53 = (unsigned int) i;
          D.21254 = i.53 * 4;
          D.21255 = p + D.21254;
          D.21262 = *D.21255;
          fprintf (gc_debug_file.42, "Overwrote field at %p with %p (was: %p)\n", D.21255, D.21262, __old);
          gc_debug_file.42 = gc_debug_file;
          fflush (gc_debug_file.42);
          <D.21261>:
          <D.21259>:
          D.21266 = sgen_ptr_in_nursery (__copy);
          if (D.21266 != 0) goto <D.21267>; else goto <D.21264>;
          <D.21267>:
          i.53 = (unsigned int) i;
          D.21254 = i.53 * 4;
          D.21268 = p + D.21254;
          D.21269 = sgen_ptr_in_nursery (D.21268);
          if (D.21269 == 0) goto <D.21270>; else goto <D.21264>;
          <D.21270>:
          iftmp.54 = 1;
          goto <D.21265>;
          <D.21264>:
          iftmp.54 = 0;
          <D.21265>:
          D.21271 = iftmp.54 != 0;
          D.21272 = (long int) D.21271;
          D.21273 = __builtin_expect (D.21272, 0);
          if (D.21273 != 0) goto <D.21274>; else goto <D.21275>;
          <D.21274>:
          i.53 = (unsigned int) i;
          D.21254 = i.53 * 4;
          D.21276 = p + D.21254;
          sgen_add_to_global_remset (D.21276, __copy);
          <D.21275>:
          <D.21257>:
        }
        i = i + 1;
        <D.20403>:
        if (i < num_refs) goto <D.20402>; else goto <D.20404>;
        <D.20404>:
        el_size.55 = (sizetype) el_size;
        e_start = e_start + el_size.55;
      }
      <D.20406>:
      if (e_start < e_end) goto <D.20405>; else goto <D.20407>;
      <D.20407>:
    }
    goto <D.21278>;
    <D.21249>:
    if (etype == 49152) goto <D.21279>; else goto <D.21280>;
    <D.21279>:
    {
      char * e_start;
      char * e_end;

      e_start = start + 16;
      D.21225 = MEM[(struct MonoArray *)start].max_length;
      el_size.50 = (unsigned int) el_size;
      D.21227 = D.21225 * el_size.50;
      e_end = e_start + D.21227;
      goto <D.20418>;
      <D.20417>:
      {
        void * * p;
        gsize _bmap;

        p = e_start;
        _bmap = desc >> 16;
        goto <D.20415>;
        <D.20414>:
        D.21281 = _bmap & 1;
        if (D.21281 != 0) goto <D.21282>; else goto <D.21283>;
        <D.21282>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.21284>; else goto <D.21285>;
          <D.21284>:
          simple_nursery_parallel_copy_object (p, queue);
          __copy = *p;
          if (0 != 0) goto <D.21286>; else goto <D.21287>;
          <D.21286>:
          if (__old != __copy) goto <D.21288>; else goto <D.21289>;
          <D.21288>:
          gc_debug_file.42 = gc_debug_file;
          D.21290 = *p;
          fprintf (gc_debug_file.42, "Overwrote field at %p with %p (was: %p)\n", p, D.21290, __old);
          gc_debug_file.42 = gc_debug_file;
          fflush (gc_debug_file.42);
          <D.21289>:
          <D.21287>:
          D.21294 = sgen_ptr_in_nursery (__copy);
          if (D.21294 != 0) goto <D.21295>; else goto <D.21292>;
          <D.21295>:
          D.21296 = sgen_ptr_in_nursery (p);
          if (D.21296 == 0) goto <D.21297>; else goto <D.21292>;
          <D.21297>:
          iftmp.56 = 1;
          goto <D.21293>;
          <D.21292>:
          iftmp.56 = 0;
          <D.21293>:
          D.21298 = iftmp.56 != 0;
          D.21299 = (long int) D.21298;
          D.21300 = __builtin_expect (D.21299, 0);
          if (D.21300 != 0) goto <D.21301>; else goto <D.21302>;
          <D.21301>:
          sgen_add_to_global_remset (p, __copy);
          <D.21302>:
          <D.21285>:
        }
        <D.21283>:
        _bmap = _bmap >> 1;
        p = p + 4;
        <D.20415>:
        if (_bmap != 0) goto <D.20414>; else goto <D.20416>;
        <D.20416>:
        el_size.55 = (sizetype) el_size;
        e_start = e_start + el_size.55;
      }
      <D.20418>:
      if (e_start < e_end) goto <D.20417>; else goto <D.20419>;
      <D.20419>:
    }
    <D.21280>:
    <D.21278>:
    <D.21247>:
  }
  <D.21219>:
  goto <D.20371>;
  <D.20420>:
  {
    void * * _objptr;
    gsize _bmap;

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

      __old = *_objptr;
      if (__old != 0B) goto <D.21306>; else goto <D.21307>;
      <D.21306>:
      simple_nursery_parallel_copy_object (_objptr, queue);
      __copy = *_objptr;
      if (0 != 0) goto <D.21308>; else goto <D.21309>;
      <D.21308>:
      if (__old != __copy) goto <D.21310>; else goto <D.21311>;
      <D.21310>:
      gc_debug_file.42 = gc_debug_file;
      D.21312 = *_objptr;
      fprintf (gc_debug_file.42, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21312, __old);
      gc_debug_file.42 = gc_debug_file;
      fflush (gc_debug_file.42);
      <D.21311>:
      <D.21309>:
      D.21316 = sgen_ptr_in_nursery (__copy);
      if (D.21316 != 0) goto <D.21317>; else goto <D.21314>;
      <D.21317>:
      D.21318 = sgen_ptr_in_nursery (_objptr);
      if (D.21318 == 0) goto <D.21319>; else goto <D.21314>;
      <D.21319>:
      iftmp.57 = 1;
      goto <D.21315>;
      <D.21314>:
      iftmp.57 = 0;
      <D.21315>:
      D.21320 = iftmp.57 != 0;
      D.21321 = (long int) D.21320;
      D.21322 = __builtin_expect (D.21321, 0);
      if (D.21322 != 0) goto <D.21323>; else goto <D.21324>;
      <D.21323>:
      sgen_add_to_global_remset (_objptr, __copy);
      <D.21324>:
      <D.21307>:
    }
    <D.21305>:
    _bmap = _bmap >> 1;
    _objptr = _objptr + 4;
    <D.20426>:
    if (_bmap != 0) goto <D.20425>; else goto <D.20427>;
    <D.20427>:
  }
  goto <D.20371>;
  <D.20428>:
  {
    void * * _objptr;
    gsize * bitmap_data;
    int bwords;
    void * * start_run;

    _objptr = start;
    bitmap_data = sgen_get_complex_descriptor (desc);
    D.21325 = *bitmap_data;
    D.21326 = D.21325 + 4294967295;
    bwords = (int) D.21326;
    start_run = _objptr;
    bitmap_data = bitmap_data + 4;
    if (0 != 0) goto <D.21327>; else goto <D.21328>;
    <D.21327>:
    {
      struct MonoObject * myobj;

      myobj = start;
      D.21329 = myobj->vtable;
      D.21330 = D.21329->klass;
      D.21331 = D.21330->name_space;
      D.21329 = myobj->vtable;
      D.21330 = D.21329->klass;
      D.21332 = D.21330->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21331, D.21332);
    }
    <D.21328>:
    goto <D.20441>;
    <D.20440>:
    {
      gsize _bmap;

      bitmap_data.58 = bitmap_data;
      bitmap_data = bitmap_data.58 + 4;
      _bmap = *bitmap_data.58;
      _objptr = start_run;
      goto <D.20438>;
      <D.20437>:
      D.21334 = _bmap & 1;
      if (D.21334 != 0) goto <D.21335>; else goto <D.21336>;
      <D.21335>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21337>; else goto <D.21338>;
        <D.21337>:
        simple_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21339>; else goto <D.21340>;
        <D.21339>:
        if (__old != __copy) goto <D.21341>; else goto <D.21342>;
        <D.21341>:
        gc_debug_file.42 = gc_debug_file;
        D.21343 = *_objptr;
        fprintf (gc_debug_file.42, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21343, __old);
        gc_debug_file.42 = gc_debug_file;
        fflush (gc_debug_file.42);
        <D.21342>:
        <D.21340>:
        D.21347 = sgen_ptr_in_nursery (__copy);
        if (D.21347 != 0) goto <D.21348>; else goto <D.21345>;
        <D.21348>:
        D.21349 = sgen_ptr_in_nursery (_objptr);
        if (D.21349 == 0) goto <D.21350>; else goto <D.21345>;
        <D.21350>:
        iftmp.59 = 1;
        goto <D.21346>;
        <D.21345>:
        iftmp.59 = 0;
        <D.21346>:
        D.21351 = iftmp.59 != 0;
        D.21352 = (long int) D.21351;
        D.21353 = __builtin_expect (D.21352, 0);
        if (D.21353 != 0) goto <D.21354>; else goto <D.21355>;
        <D.21354>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21355>:
        <D.21338>:
      }
      <D.21336>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20438>:
      if (_bmap != 0) goto <D.20437>; else goto <D.20439>;
      <D.20439>:
      start_run = start_run + 128;
    }
    <D.20441>:
    bwords.60 = bwords;
    bwords = bwords.60 + -1;
    if (bwords.60 > 0) goto <D.20440>; else goto <D.20442>;
    <D.20442>:
  }
  goto <D.20371>;
  <D.20443>:
  goto <D.20371>;
  <D.20444>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
  <D.20371>:
}


simple_nursery_parallel_scan_object (char * start, struct SgenGrayQueue * queue)
{
  unsigned int D.21358;
  unsigned int D.21359;
  unsigned int D.21360;
  unsigned int D.21361;
  unsigned int D.21364;
  unsigned int D.21365;
  unsigned int D.21366;
  unsigned int D.21367;
  unsigned int D.21368;
  struct FILE * gc_debug_file.61;
  void * D.21376;
  int iftmp.62;
  int D.21380;
  int D.21382;
  _Bool D.21384;
  long int D.21385;
  long int D.21386;
  int iftmp.63;
  int D.21398;
  int D.21400;
  _Bool D.21402;
  long int D.21403;
  long int D.21404;
  unsigned int _index.64;
  unsigned int D.21408;
  int D.21409;
  void * D.21416;
  int iftmp.65;
  int D.21420;
  int D.21422;
  _Bool D.21424;
  long int D.21425;
  long int D.21426;
  unsigned int _index.66;
  unsigned int D.21430;
  int D.21431;
  int iftmp.67;
  int D.21441;
  int D.21443;
  _Bool D.21445;
  long int D.21446;
  long int D.21447;
  unsigned int D.21450;
  unsigned int D.21453;
  int D.21454;
  int desc.68;
  unsigned int D.21458;
  unsigned int el_size.69;
  unsigned int D.21460;
  void * D.21467;
  int iftmp.70;
  int D.21471;
  int D.21473;
  _Bool D.21475;
  long int D.21476;
  long int D.21477;
  int D.21483;
  unsigned int offset.71;
  unsigned int D.21485;
  unsigned int i.72;
  unsigned int D.21487;
  void * * D.21488;
  void * D.21495;
  int iftmp.73;
  int D.21499;
  void * D.21501;
  int D.21502;
  _Bool D.21504;
  long int D.21505;
  long int D.21506;
  void * D.21509;
  sizetype el_size.74;
  unsigned int D.21514;
  void * D.21523;
  int iftmp.75;
  int D.21527;
  int D.21529;
  _Bool D.21531;
  long int D.21532;
  long int D.21533;
  unsigned int D.21536;
  void * D.21545;
  int iftmp.76;
  int D.21549;
  int D.21551;
  _Bool D.21553;
  long int D.21554;
  long int D.21555;
  unsigned int D.21558;
  unsigned int D.21559;
  struct MonoVTable * D.21562;
  struct MonoClass * D.21563;
  const char * D.21564;
  const char * D.21565;
  gsize * bitmap_data.77;
  unsigned int D.21567;
  void * D.21576;
  int iftmp.78;
  int D.21580;
  int D.21582;
  _Bool D.21584;
  long int D.21585;
  long int D.21586;
  int bwords.79;
  unsigned int D.21590;
  gsize * mbitmap_data.80;
  unsigned int D.21592;
  unsigned int D.21593;
  struct MonoClass * D.21594;
  unsigned int el_size.81;
  unsigned int D.21596;
  const char * D.21599;
  const char * D.21600;
  gsize * bitmap_data.82;
  unsigned int D.21602;
  void * D.21611;
  int iftmp.83;
  int D.21615;
  int D.21617;
  _Bool D.21619;
  long int D.21620;
  long int D.21621;
  unsigned int bwords.84;
  sizetype el_size.85;

  {
    struct GCVTable * vt;
    mword desc;

    D.21358 = MEM[(mword *)start];
    D.21359 = D.21358 & 4294967292;
    vt = (struct GCVTable *) D.21359;
    desc = vt->desc;
    D.21360 = desc & 7;
    switch (D.21360) <default: <D.20355>, case 1: <D.20250>, case 2: <D.20261>, case 3: <D.20317>, case 4: <D.20273>, case 5: <D.20309>, case 6: <D.20332>, case 7: <D.20354>>
    <D.20250>:
    D.21361 = desc & 4294901760;
    if (D.21361 != 0) goto <D.21362>; else goto <D.21363>;
    <D.21362>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.21364 = desc >> 16;
      D.21365 = D.21364 & 255;
      D.21366 = D.21365 * 4;
      _objptr = _objptr + D.21366;
      D.21367 = desc >> 24;
      D.21368 = D.21367 * 4;
      _objptr_end = _objptr + D.21368;
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21369>; else goto <D.21370>;
        <D.21369>:
        simple_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21371>; else goto <D.21372>;
        <D.21371>:
        if (__old != __copy) goto <D.21373>; else goto <D.21374>;
        <D.21373>:
        gc_debug_file.61 = gc_debug_file;
        D.21376 = *_objptr;
        fprintf (gc_debug_file.61, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21376, __old);
        gc_debug_file.61 = gc_debug_file;
        fflush (gc_debug_file.61);
        <D.21374>:
        <D.21372>:
        D.21380 = sgen_ptr_in_nursery (__copy);
        if (D.21380 != 0) goto <D.21381>; else goto <D.21378>;
        <D.21381>:
        D.21382 = sgen_ptr_in_nursery (_objptr);
        if (D.21382 == 0) goto <D.21383>; else goto <D.21378>;
        <D.21383>:
        iftmp.62 = 1;
        goto <D.21379>;
        <D.21378>:
        iftmp.62 = 0;
        <D.21379>:
        D.21384 = iftmp.62 != 0;
        D.21385 = (long int) D.21384;
        D.21386 = __builtin_expect (D.21385, 0);
        if (D.21386 != 0) goto <D.21387>; else goto <D.21388>;
        <D.21387>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21388>:
        <D.21370>:
      }
      _objptr = _objptr + 4;
      goto <D.20258>;
      <D.20257>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21389>; else goto <D.21390>;
        <D.21389>:
        simple_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21391>; else goto <D.21392>;
        <D.21391>:
        if (__old != __copy) goto <D.21393>; else goto <D.21394>;
        <D.21393>:
        gc_debug_file.61 = gc_debug_file;
        D.21376 = *_objptr;
        fprintf (gc_debug_file.61, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21376, __old);
        gc_debug_file.61 = gc_debug_file;
        fflush (gc_debug_file.61);
        <D.21394>:
        <D.21392>:
        D.21398 = sgen_ptr_in_nursery (__copy);
        if (D.21398 != 0) goto <D.21399>; else goto <D.21396>;
        <D.21399>:
        D.21400 = sgen_ptr_in_nursery (_objptr);
        if (D.21400 == 0) goto <D.21401>; else goto <D.21396>;
        <D.21401>:
        iftmp.63 = 1;
        goto <D.21397>;
        <D.21396>:
        iftmp.63 = 0;
        <D.21397>:
        D.21402 = iftmp.63 != 0;
        D.21403 = (long int) D.21402;
        D.21404 = __builtin_expect (D.21403, 0);
        if (D.21404 != 0) goto <D.21405>; else goto <D.21406>;
        <D.21405>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21406>:
        <D.21390>:
      }
      _objptr = _objptr + 4;
      <D.20258>:
      if (_objptr < _objptr_end) goto <D.20257>; else goto <D.20259>;
      <D.20259>:
    }
    <D.21363>:
    goto <D.20260>;
    <D.20261>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.64 = (unsigned int) _index;
        D.21408 = _index.64 * 4;
        _objptr = _objptr + D.21408;
        D.21409 = _index + 1;
        _bmap = _bmap >> D.21409;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21410>; else goto <D.21411>;
          <D.21410>:
          simple_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21412>; else goto <D.21413>;
          <D.21412>:
          if (__old != __copy) goto <D.21414>; else goto <D.21415>;
          <D.21414>:
          gc_debug_file.61 = gc_debug_file;
          D.21416 = *_objptr;
          fprintf (gc_debug_file.61, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21416, __old);
          gc_debug_file.61 = gc_debug_file;
          fflush (gc_debug_file.61);
          <D.21415>:
          <D.21413>:
          D.21420 = sgen_ptr_in_nursery (__copy);
          if (D.21420 != 0) goto <D.21421>; else goto <D.21418>;
          <D.21421>:
          D.21422 = sgen_ptr_in_nursery (_objptr);
          if (D.21422 == 0) goto <D.21423>; else goto <D.21418>;
          <D.21423>:
          iftmp.65 = 1;
          goto <D.21419>;
          <D.21418>:
          iftmp.65 = 0;
          <D.21419>:
          D.21424 = iftmp.65 != 0;
          D.21425 = (long int) D.21424;
          D.21426 = __builtin_expect (D.21425, 0);
          if (D.21426 != 0) goto <D.21427>; else goto <D.21428>;
          <D.21427>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21428>:
          <D.21411>:
        }
        _objptr = _objptr + 4;
      }
      goto <D.20271>;
      <D.20270>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.66 = (unsigned int) _index;
        D.21430 = _index.66 * 4;
        _objptr = _objptr + D.21430;
        D.21431 = _index + 1;
        _bmap = _bmap >> D.21431;
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21432>; else goto <D.21433>;
          <D.21432>:
          simple_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21434>; else goto <D.21435>;
          <D.21434>:
          if (__old != __copy) goto <D.21436>; else goto <D.21437>;
          <D.21436>:
          gc_debug_file.61 = gc_debug_file;
          D.21416 = *_objptr;
          fprintf (gc_debug_file.61, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21416, __old);
          gc_debug_file.61 = gc_debug_file;
          fflush (gc_debug_file.61);
          <D.21437>:
          <D.21435>:
          D.21441 = sgen_ptr_in_nursery (__copy);
          if (D.21441 != 0) goto <D.21442>; else goto <D.21439>;
          <D.21442>:
          D.21443 = sgen_ptr_in_nursery (_objptr);
          if (D.21443 == 0) goto <D.21444>; else goto <D.21439>;
          <D.21444>:
          iftmp.67 = 1;
          goto <D.21440>;
          <D.21439>:
          iftmp.67 = 0;
          <D.21440>:
          D.21445 = iftmp.67 != 0;
          D.21446 = (long int) D.21445;
          D.21447 = __builtin_expect (D.21446, 0);
          if (D.21447 != 0) goto <D.21448>; else goto <D.21449>;
          <D.21448>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21449>:
          <D.21433>:
        }
        _objptr = _objptr + 4;
      }
      <D.20271>:
      if (_bmap != 0) goto <D.20270>; else goto <D.20272>;
      <D.20272>:
    }
    goto <D.20260>;
    <D.20273>:
    D.21450 = desc & 4294950912;
    if (D.21450 != 0) goto <D.21451>; else goto <D.21452>;
    <D.21451>:
    {
      int el_size;
      int etype;

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

        p = start + 16;
        D.21458 = MEM[(struct MonoArray *)start].max_length;
        el_size.69 = (unsigned int) el_size;
        D.21460 = D.21458 * el_size.69;
        end_refs = p + D.21460;
        goto <D.20281>;
        <D.20280>:
        {
          void * __old;
          void * __copy;

          __old = *p;
          if (__old != 0B) goto <D.21461>; else goto <D.21462>;
          <D.21461>:
          simple_nursery_parallel_copy_object (p, queue);
          __copy = *p;
          if (0 != 0) goto <D.21463>; else goto <D.21464>;
          <D.21463>:
          if (__old != __copy) goto <D.21465>; else goto <D.21466>;
          <D.21465>:
          gc_debug_file.61 = gc_debug_file;
          D.21467 = *p;
          fprintf (gc_debug_file.61, "Overwrote field at %p with %p (was: %p)\n", p, D.21467, __old);
          gc_debug_file.61 = gc_debug_file;
          fflush (gc_debug_file.61);
          <D.21466>:
          <D.21464>:
          D.21471 = sgen_ptr_in_nursery (__copy);
          if (D.21471 != 0) goto <D.21472>; else goto <D.21469>;
          <D.21472>:
          D.21473 = sgen_ptr_in_nursery (p);
          if (D.21473 == 0) goto <D.21474>; else goto <D.21469>;
          <D.21474>:
          iftmp.70 = 1;
          goto <D.21470>;
          <D.21469>:
          iftmp.70 = 0;
          <D.21470>:
          D.21475 = iftmp.70 != 0;
          D.21476 = (long int) D.21475;
          D.21477 = __builtin_expect (D.21476, 0);
          if (D.21477 != 0) goto <D.21478>; else goto <D.21479>;
          <D.21478>:
          sgen_add_to_global_remset (p, __copy);
          <D.21479>:
          <D.21462>:
        }
        p = p + 4;
        <D.20281>:
        if (p < end_refs) goto <D.20280>; else goto <D.20282>;
        <D.20282>:
      }
      goto <D.21480>;
      <D.21457>:
      if (etype == 32768) goto <D.21481>; else goto <D.21482>;
      <D.21481>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.21364 = desc >> 16;
        D.21483 = (int) D.21364;
        offset = D.21483 & 255;
        D.21367 = desc >> 24;
        num_refs = (int) D.21367;
        e_start = start + 16;
        D.21458 = MEM[(struct MonoArray *)start].max_length;
        el_size.69 = (unsigned int) el_size;
        D.21460 = D.21458 * el_size.69;
        e_end = e_start + D.21460;
        goto <D.20295>;
        <D.20294>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.71 = (unsigned int) offset;
          D.21485 = offset.71 * 4;
          p = p + D.21485;
          i = 0;
          goto <D.20292>;
          <D.20291>:
          {
            void * __old;
            void * __copy;

            i.72 = (unsigned int) i;
            D.21487 = i.72 * 4;
            D.21488 = p + D.21487;
            __old = *D.21488;
            if (__old != 0B) goto <D.21489>; else goto <D.21490>;
            <D.21489>:
            i.72 = (unsigned int) i;
            D.21487 = i.72 * 4;
            D.21488 = p + D.21487;
            simple_nursery_parallel_copy_object (D.21488, queue);
            i.72 = (unsigned int) i;
            D.21487 = i.72 * 4;
            D.21488 = p + D.21487;
            __copy = *D.21488;
            if (0 != 0) goto <D.21491>; else goto <D.21492>;
            <D.21491>:
            if (__old != __copy) goto <D.21493>; else goto <D.21494>;
            <D.21493>:
            gc_debug_file.61 = gc_debug_file;
            i.72 = (unsigned int) i;
            D.21487 = i.72 * 4;
            D.21488 = p + D.21487;
            i.72 = (unsigned int) i;
            D.21487 = i.72 * 4;
            D.21488 = p + D.21487;
            D.21495 = *D.21488;
            fprintf (gc_debug_file.61, "Overwrote field at %p with %p (was: %p)\n", D.21488, D.21495, __old);
            gc_debug_file.61 = gc_debug_file;
            fflush (gc_debug_file.61);
            <D.21494>:
            <D.21492>:
            D.21499 = sgen_ptr_in_nursery (__copy);
            if (D.21499 != 0) goto <D.21500>; else goto <D.21497>;
            <D.21500>:
            i.72 = (unsigned int) i;
            D.21487 = i.72 * 4;
            D.21501 = p + D.21487;
            D.21502 = sgen_ptr_in_nursery (D.21501);
            if (D.21502 == 0) goto <D.21503>; else goto <D.21497>;
            <D.21503>:
            iftmp.73 = 1;
            goto <D.21498>;
            <D.21497>:
            iftmp.73 = 0;
            <D.21498>:
            D.21504 = iftmp.73 != 0;
            D.21505 = (long int) D.21504;
            D.21506 = __builtin_expect (D.21505, 0);
            if (D.21506 != 0) goto <D.21507>; else goto <D.21508>;
            <D.21507>:
            i.72 = (unsigned int) i;
            D.21487 = i.72 * 4;
            D.21509 = p + D.21487;
            sgen_add_to_global_remset (D.21509, __copy);
            <D.21508>:
            <D.21490>:
          }
          i = i + 1;
          <D.20292>:
          if (i < num_refs) goto <D.20291>; else goto <D.20293>;
          <D.20293>:
          el_size.74 = (sizetype) el_size;
          e_start = e_start + el_size.74;
        }
        <D.20295>:
        if (e_start < e_end) goto <D.20294>; else goto <D.20296>;
        <D.20296>:
      }
      goto <D.21511>;
      <D.21482>:
      if (etype == 49152) goto <D.21512>; else goto <D.21513>;
      <D.21512>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.21458 = MEM[(struct MonoArray *)start].max_length;
        el_size.69 = (unsigned int) el_size;
        D.21460 = D.21458 * el_size.69;
        e_end = e_start + D.21460;
        goto <D.20307>;
        <D.20306>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.20304>;
          <D.20303>:
          D.21514 = _bmap & 1;
          if (D.21514 != 0) goto <D.21515>; else goto <D.21516>;
          <D.21515>:
          {
            void * __old;
            void * __copy;

            __old = *p;
            if (__old != 0B) goto <D.21517>; else goto <D.21518>;
            <D.21517>:
            simple_nursery_parallel_copy_object (p, queue);
            __copy = *p;
            if (0 != 0) goto <D.21519>; else goto <D.21520>;
            <D.21519>:
            if (__old != __copy) goto <D.21521>; else goto <D.21522>;
            <D.21521>:
            gc_debug_file.61 = gc_debug_file;
            D.21523 = *p;
            fprintf (gc_debug_file.61, "Overwrote field at %p with %p (was: %p)\n", p, D.21523, __old);
            gc_debug_file.61 = gc_debug_file;
            fflush (gc_debug_file.61);
            <D.21522>:
            <D.21520>:
            D.21527 = sgen_ptr_in_nursery (__copy);
            if (D.21527 != 0) goto <D.21528>; else goto <D.21525>;
            <D.21528>:
            D.21529 = sgen_ptr_in_nursery (p);
            if (D.21529 == 0) goto <D.21530>; else goto <D.21525>;
            <D.21530>:
            iftmp.75 = 1;
            goto <D.21526>;
            <D.21525>:
            iftmp.75 = 0;
            <D.21526>:
            D.21531 = iftmp.75 != 0;
            D.21532 = (long int) D.21531;
            D.21533 = __builtin_expect (D.21532, 0);
            if (D.21533 != 0) goto <D.21534>; else goto <D.21535>;
            <D.21534>:
            sgen_add_to_global_remset (p, __copy);
            <D.21535>:
            <D.21518>:
          }
          <D.21516>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.20304>:
          if (_bmap != 0) goto <D.20303>; else goto <D.20305>;
          <D.20305>:
          el_size.74 = (sizetype) el_size;
          e_start = e_start + el_size.74;
        }
        <D.20307>:
        if (e_start < e_end) goto <D.20306>; else goto <D.20308>;
        <D.20308>:
      }
      <D.21513>:
      <D.21511>:
      <D.21480>:
    }
    <D.21452>:
    goto <D.20260>;
    <D.20309>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.20315>;
      <D.20314>:
      D.21536 = _bmap & 1;
      if (D.21536 != 0) goto <D.21537>; else goto <D.21538>;
      <D.21537>:
      {
        void * __old;
        void * __copy;

        __old = *_objptr;
        if (__old != 0B) goto <D.21539>; else goto <D.21540>;
        <D.21539>:
        simple_nursery_parallel_copy_object (_objptr, queue);
        __copy = *_objptr;
        if (0 != 0) goto <D.21541>; else goto <D.21542>;
        <D.21541>:
        if (__old != __copy) goto <D.21543>; else goto <D.21544>;
        <D.21543>:
        gc_debug_file.61 = gc_debug_file;
        D.21545 = *_objptr;
        fprintf (gc_debug_file.61, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21545, __old);
        gc_debug_file.61 = gc_debug_file;
        fflush (gc_debug_file.61);
        <D.21544>:
        <D.21542>:
        D.21549 = sgen_ptr_in_nursery (__copy);
        if (D.21549 != 0) goto <D.21550>; else goto <D.21547>;
        <D.21550>:
        D.21551 = sgen_ptr_in_nursery (_objptr);
        if (D.21551 == 0) goto <D.21552>; else goto <D.21547>;
        <D.21552>:
        iftmp.76 = 1;
        goto <D.21548>;
        <D.21547>:
        iftmp.76 = 0;
        <D.21548>:
        D.21553 = iftmp.76 != 0;
        D.21554 = (long int) D.21553;
        D.21555 = __builtin_expect (D.21554, 0);
        if (D.21555 != 0) goto <D.21556>; else goto <D.21557>;
        <D.21556>:
        sgen_add_to_global_remset (_objptr, __copy);
        <D.21557>:
        <D.21540>:
      }
      <D.21538>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20315>:
      if (_bmap != 0) goto <D.20314>; else goto <D.20316>;
      <D.20316>:
    }
    goto <D.20260>;
    <D.20317>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

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

        myobj = start;
        D.21562 = myobj->vtable;
        D.21563 = D.21562->klass;
        D.21564 = D.21563->name_space;
        D.21562 = myobj->vtable;
        D.21563 = D.21562->klass;
        D.21565 = D.21563->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21564, D.21565);
      }
      <D.21561>:
      goto <D.20330>;
      <D.20329>:
      {
        gsize _bmap;

        bitmap_data.77 = bitmap_data;
        bitmap_data = bitmap_data.77 + 4;
        _bmap = *bitmap_data.77;
        _objptr = start_run;
        goto <D.20327>;
        <D.20326>:
        D.21567 = _bmap & 1;
        if (D.21567 != 0) goto <D.21568>; else goto <D.21569>;
        <D.21568>:
        {
          void * __old;
          void * __copy;

          __old = *_objptr;
          if (__old != 0B) goto <D.21570>; else goto <D.21571>;
          <D.21570>:
          simple_nursery_parallel_copy_object (_objptr, queue);
          __copy = *_objptr;
          if (0 != 0) goto <D.21572>; else goto <D.21573>;
          <D.21572>:
          if (__old != __copy) goto <D.21574>; else goto <D.21575>;
          <D.21574>:
          gc_debug_file.61 = gc_debug_file;
          D.21576 = *_objptr;
          fprintf (gc_debug_file.61, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21576, __old);
          gc_debug_file.61 = gc_debug_file;
          fflush (gc_debug_file.61);
          <D.21575>:
          <D.21573>:
          D.21580 = sgen_ptr_in_nursery (__copy);
          if (D.21580 != 0) goto <D.21581>; else goto <D.21578>;
          <D.21581>:
          D.21582 = sgen_ptr_in_nursery (_objptr);
          if (D.21582 == 0) goto <D.21583>; else goto <D.21578>;
          <D.21583>:
          iftmp.78 = 1;
          goto <D.21579>;
          <D.21578>:
          iftmp.78 = 0;
          <D.21579>:
          D.21584 = iftmp.78 != 0;
          D.21585 = (long int) D.21584;
          D.21586 = __builtin_expect (D.21585, 0);
          if (D.21586 != 0) goto <D.21587>; else goto <D.21588>;
          <D.21587>:
          sgen_add_to_global_remset (_objptr, __copy);
          <D.21588>:
          <D.21571>:
        }
        <D.21569>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.20327>:
        if (_bmap != 0) goto <D.20326>; else goto <D.20328>;
        <D.20328>:
        start_run = start_run + 128;
      }
      <D.20330>:
      bwords.79 = bwords;
      bwords = bwords.79 + -1;
      if (bwords.79 > 0) goto <D.20329>; else goto <D.20331>;
      <D.20331>:
    }
    goto <D.20260>;
    <D.20332>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.21590 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.21590);
      mbitmap_data.80 = mbitmap_data;
      mbitmap_data = mbitmap_data.80 + 4;
      D.21592 = *mbitmap_data.80;
      D.21593 = D.21592 + 4294967295;
      mbwords = (int) D.21593;
      D.21594 = vt->klass;
      el_size = mono_array_element_size (D.21594);
      e_start = start + 16;
      D.21458 = MEM[(struct MonoArray *)start].max_length;
      el_size.81 = (unsigned int) el_size;
      D.21596 = D.21458 * el_size.81;
      e_end = e_start + D.21596;
      if (0 != 0) goto <D.21597>; else goto <D.21598>;
      <D.21597>:
      D.21590 = vt->desc;
      D.21594 = vt->klass;
      D.21599 = D.21594->name_space;
      D.21594 = vt->klass;
      D.21600 = D.21594->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.21590, D.21599, D.21600);
      <D.21598>:
      goto <D.20352>;
      <D.20351>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.82 = bitmap_data;
          bitmap_data = bitmap_data.82 + 4;
          _bmap = *bitmap_data.82;
          start_run = _objptr;
          goto <D.20346>;
          <D.20345>:
          D.21602 = _bmap & 1;
          if (D.21602 != 0) goto <D.21603>; else goto <D.21604>;
          <D.21603>:
          {
            void * __old;
            void * __copy;

            __old = *_objptr;
            if (__old != 0B) goto <D.21605>; else goto <D.21606>;
            <D.21605>:
            simple_nursery_parallel_copy_object (_objptr, queue);
            __copy = *_objptr;
            if (0 != 0) goto <D.21607>; else goto <D.21608>;
            <D.21607>:
            if (__old != __copy) goto <D.21609>; else goto <D.21610>;
            <D.21609>:
            gc_debug_file.61 = gc_debug_file;
            D.21611 = *_objptr;
            fprintf (gc_debug_file.61, "Overwrote field at %p with %p (was: %p)\n", _objptr, D.21611, __old);
            gc_debug_file.61 = gc_debug_file;
            fflush (gc_debug_file.61);
            <D.21610>:
            <D.21608>:
            D.21615 = sgen_ptr_in_nursery (__copy);
            if (D.21615 != 0) goto <D.21616>; else goto <D.21613>;
            <D.21616>:
            D.21617 = sgen_ptr_in_nursery (_objptr);
            if (D.21617 == 0) goto <D.21618>; else goto <D.21613>;
            <D.21618>:
            iftmp.83 = 1;
            goto <D.21614>;
            <D.21613>:
            iftmp.83 = 0;
            <D.21614>:
            D.21619 = iftmp.83 != 0;
            D.21620 = (long int) D.21619;
            D.21621 = __builtin_expect (D.21620, 0);
            if (D.21621 != 0) goto <D.21622>; else goto <D.21623>;
            <D.21622>:
            sgen_add_to_global_remset (_objptr, __copy);
            <D.21623>:
            <D.21606>:
          }
          <D.21604>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.20346>:
          if (_bmap != 0) goto <D.20345>; else goto <D.20347>;
          <D.20347>:
          _objptr = start_run + 128;
        }
        <D.20349>:
        bwords.84 = bwords;
        bwords = bwords.84 + 4294967295;
        if (bwords.84 != 0) goto <D.20348>; else goto <D.20350>;
        <D.20350>:
        el_size.85 = (sizetype) el_size;
        e_start = e_start + el_size.85;
      }
      <D.20352>:
      if (e_start < e_end) goto <D.20351>; else goto <D.20353>;
      <D.20353>:
    }
    goto <D.20260>;
    <D.20354>:
    goto <D.20260>;
    <D.20355>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.20260>:
  }
}


simple_nursery_parallel_copy_object (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.86;
  int D.21630;
  unsigned int D.21633;
  unsigned int D.21634;
  unsigned int D.21637;
  int D.21640;
  unsigned int D.21643;
  unsigned int D.21644;
  void * D.21645;
  unsigned int D.21646;
  _Bool D.21647;
  long int D.21648;
  long int D.21649;
  unsigned int destination.87;
  unsigned int D.21653;
  void * D.21654;
  void * D.21655;
  struct SgenGrayQueue * iftmp.88;
  int D.21663;
  _Bool D.21667;
  long int D.21668;
  long int D.21669;
  char * obj;
  mword vtable_word;
  mword objsize;
  struct MonoVTable * vt;
  void * destination;
  gboolean has_references;

  obj = *obj_slot;
  if (0 != 0) goto <D.21627>; else goto <D.21628>;
  <D.21627>:
  current_collection_generation.86 = current_collection_generation;
  monoeg_g_log (0B, 4, "calling minor-par-copy from a %d generation collection", current_collection_generation.86);
  <D.20242>:
  goto <D.20242>;
  <D.21628>:
  D.21630 = sgen_ptr_in_nursery (obj);
  if (D.21630 == 0) goto <D.21631>; else goto <D.21632>;
  <D.21631>:
  return;
  <D.21632>:
  vtable_word = MEM[(mword *)obj];
  D.21633 = vtable_word & 4294967292;
  vt = (struct MonoVTable *) D.21633;
  D.21634 = vtable_word & 1;
  if (D.21634 != 0) goto <D.21635>; else goto <D.21636>;
  <D.21635>:
  *obj_slot = vt;
  return;
  <D.21636>:
  D.21637 = vtable_word & 2;
  if (D.21637 != 0) goto <D.21638>; else goto <D.21639>;
  <D.21638>:
  return;
  <D.21639>:
  D.21640 = sgen_nursery_is_to_space (obj);
  if (D.21640 != 0) goto <D.21641>; else goto <D.21642>;
  <D.21641>:
  return;
  <D.21642>:
  D.21643 = sgen_par_object_get_size (vt, obj);
  D.21644 = D.21643 + 7;
  objsize = D.21644 & 4294967288;
  D.21645 = vt->gc_descr;
  D.21646 = (unsigned int) D.21645;
  has_references = sgen_gc_descr_has_references (D.21646);
  destination = par_alloc_for_promotion (vt, obj, objsize, has_references);
  D.21647 = destination == 0B;
  D.21648 = (long int) D.21647;
  D.21649 = __builtin_expect (D.21648, 0);
  if (D.21649 != 0) goto <D.21650>; else goto <D.21651>;
  <D.21650>:
  sgen_parallel_pin_or_update (obj_slot, obj, vt, queue);
  return;
  <D.21651>:
  MEM[(struct MonoVTable * *)destination] = vt;
  destination.87 = (unsigned int) destination;
  D.21653 = destination.87 | 1;
  D.21654 = (void *) D.21653;
  D.21655 = InterlockedCompareExchangePointer (obj, D.21654, vt);
  if (D.21655 == vt) goto <D.21656>; else goto <D.21657>;
  <D.21656>:
  if (has_references != 0) goto <D.21659>; else goto <D.21660>;
  <D.21659>:
  iftmp.88 = queue;
  goto <D.21661>;
  <D.21660>:
  iftmp.88 = 0B;
  <D.21661>:
  par_copy_object_no_checks (destination, vt, obj, objsize, iftmp.88);
  obj = destination;
  *obj_slot = obj;
  goto <D.21662>;
  <D.21657>:
  D.21663 = sgen_ptr_in_nursery (destination);
  if (D.21663 == 0) goto <D.21664>; else goto <D.21665>;
  <D.21664>:
  MEM[(void * *)destination] = 0B;
  goto <D.21666>;
  <D.21665>:
  memset (destination, 0, objsize);
  <D.21666>:
  vtable_word = MEM[(mword *)obj];
  D.21634 = vtable_word & 1;
  D.21667 = D.21634 == 0;
  D.21668 = (long int) D.21667;
  D.21669 = __builtin_expect (D.21668, 0);
  if (D.21669 != 0) goto <D.21670>; else goto <D.21671>;
  <D.21670>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-minor-copy-object.h", 291, "vtable_word & SGEN_FORWARDED_BIT");
  <D.21671>:
  D.21633 = vtable_word & 4294967292;
  obj = (char *) D.21633;
  *obj_slot = obj;
  <D.21662>:
}


sgen_nursery_is_to_space (char * object)
{
  int object.89;
  char * sgen_nursery_start.90;
  int sgen_nursery_start.91;
  int D.21676;
  int D.21677;
  _Bool D.21678;
  long int D.21679;
  long int D.21680;
  char * D.21683;
  char * D.21684;
  int sgen_space_bitmap_size.92;
  _Bool D.21686;
  long int D.21687;
  long int D.21688;
  gboolean D.21691;
  char * sgen_space_bitmap.93;
  sizetype byte.94;
  char * D.21694;
  char D.21695;
  int D.21696;
  int D.21697;
  int D.21698;
  _Bool D.21699;
  int idx;
  int byte;
  int bit;

  object.89 = (int) object;
  sgen_nursery_start.90 = sgen_nursery_start;
  sgen_nursery_start.91 = (int) sgen_nursery_start.90;
  D.21676 = object.89 - sgen_nursery_start.91;
  idx = D.21676 >> 9;
  byte = idx / 8;
  bit = idx & 7;
  D.21677 = sgen_ptr_in_nursery (object);
  D.21678 = D.21677 == 0;
  D.21679 = (long int) D.21678;
  D.21680 = __builtin_expect (D.21679, 0);
  if (D.21680 != 0) goto <D.21681>; else goto <D.21682>;
  <D.21681>:
  D.21683 = sgen_get_nursery_start ();
  D.21684 = sgen_get_nursery_end ();
  monoeg_g_log (0B, 4, "object %p is not in nursery [%p - %p]", object, D.21683, D.21684);
  <D.19631>:
  goto <D.19631>;
  <D.21682>:
  sgen_space_bitmap_size.92 = sgen_space_bitmap_size;
  D.21686 = byte >= sgen_space_bitmap_size.92;
  D.21687 = (long int) D.21686;
  D.21688 = __builtin_expect (D.21687, 0);
  if (D.21688 != 0) goto <D.21689>; else goto <D.21690>;
  <D.21689>:
  sgen_space_bitmap_size.92 = sgen_space_bitmap_size;
  monoeg_g_log (0B, 4, "byte index %d out of range", byte, sgen_space_bitmap_size.92);
  <D.19632>:
  goto <D.19632>;
  <D.21690>:
  sgen_space_bitmap.93 = sgen_space_bitmap;
  byte.94 = (sizetype) byte;
  D.21694 = sgen_space_bitmap.93 + byte.94;
  D.21695 = *D.21694;
  D.21696 = (int) D.21695;
  D.21697 = D.21696 >> bit;
  D.21698 = D.21697 & 1;
  D.21699 = D.21698 != 0;
  D.21691 = (gboolean) D.21699;
  return D.21691;
}


sgen_get_nursery_start ()
{
  char * D.21701;

  D.21701 = sgen_nursery_start;
  return D.21701;
}


sgen_get_nursery_end ()
{
  char * D.21703;

  D.21703 = sgen_nursery_end;
  return D.21703;
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.21705;
  unsigned int comp.95;
  unsigned int exch.96;
  unsigned int D.21708;

  comp.95 = (unsigned int) comp;
  exch.96 = (unsigned int) exch;
  D.21708 = __sync_val_compare_and_swap_4 (dest, comp.95, exch.96);
  D.21705 = (void *) D.21708;
  return D.21705;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.21712;
  int D.21717;
  void * D.21719;
  unsigned int D.21720;

  D.21712 = __builtin_constant_p (__len);
  if (D.21712 != 0) goto <D.21713>; else goto <D.21714>;
  <D.21713>:
  if (__len == 0) goto <D.21715>; else goto <D.21716>;
  <D.21715>:
  D.21717 = __builtin_constant_p (__ch);
  if (D.21717 == 0) goto <D.21710>; else goto <D.21718>;
  <D.21718>:
  if (__ch != 0) goto <D.21710>; else goto <D.21711>;
  <D.21710>:
  __warn_memset_zero_len ();
  D.21719 = __dest;
  return D.21719;
  <D.21711>:
  <D.21716>:
  <D.21714>:
  D.21720 = __builtin_object_size (__dest, 0);
  D.21719 = __builtin___memset_chk (__dest, __ch, __len, D.21720);
  return D.21719;
}


simple_nursery_serial_copy_object (void * * obj_slot, struct SgenGrayQueue * queue)
{
  int current_collection_generation.97;
  int D.21725;
  struct FILE * gc_debug_file.98;
  char * iftmp.99;
  unsigned int D.21732;
  unsigned int D.21733;
  unsigned int D.21736;
  unsigned int D.21744;
  _Bool D.21745;
  long int D.21746;
  long int D.21747;
  void * D.21754;
  char * forwarded;
  char * obj;

  obj = *obj_slot;
  if (0 != 0) goto <D.21722>; else goto <D.21723>;
  <D.21722>:
  current_collection_generation.97 = current_collection_generation;
  monoeg_g_log (0B, 4, "calling minor-serial-copy from a %d generation collection", current_collection_generation.97);
  <D.20219>:
  goto <D.20219>;
  <D.21723>:
  D.21725 = sgen_ptr_in_nursery (obj);
  if (D.21725 == 0) goto <D.21726>; else goto <D.21727>;
  <D.21726>:
  return;
  <D.21727>:
  if (0 != 0) goto <D.21728>; else goto <D.21729>;
  <D.21728>:
  gc_debug_file.98 = gc_debug_file;
  fprintf (gc_debug_file.98, "Precise copy of %p from %p\n", obj, obj_slot);
  gc_debug_file.98 = gc_debug_file;
  fflush (gc_debug_file.98);
  <D.21729>:
  D.21732 = MEM[(mword *)obj];
  D.21733 = D.21732 & 1;
  if (D.21733 != 0) goto <D.21734>; else goto <D.21735>;
  <D.21734>:
  D.21732 = MEM[(mword *)obj];
  D.21736 = D.21732 & 4294967292;
  iftmp.99 = (char *) D.21736;
  goto <D.21737>;
  <D.21735>:
  iftmp.99 = 0B;
  <D.21737>:
  forwarded = iftmp.99;
  if (forwarded != 0B) goto <D.21738>; else goto <D.21739>;
  <D.21738>:
  if (0 != 0) goto <D.21740>; else goto <D.21741>;
  <D.21740>:
  monoeg_g_log (0B, 4, "forwarded object %p has no gc descriptor", forwarded);
  <D.20220>:
  goto <D.20220>;
  <D.21741>:
  if (0 != 0) goto <D.21742>; else goto <D.21743>;
  <D.21742>:
  gc_debug_file.98 = gc_debug_file;
  fprintf (gc_debug_file.98, " (already forwarded to %p)\n", forwarded);
  gc_debug_file.98 = gc_debug_file;
  fflush (gc_debug_file.98);
  <D.21743>:
  *obj_slot = forwarded;
  return;
  <D.21739>:
  D.21732 = MEM[(mword *)obj];
  D.21744 = D.21732 & 2;
  D.21745 = D.21744 != 0;
  D.21746 = (long int) D.21745;
  D.21747 = __builtin_expect (D.21746, 0);
  if (D.21747 != 0) goto <D.21748>; else goto <D.21749>;
  <D.21748>:
  if (0 != 0) goto <D.21750>; else goto <D.21751>;
  <D.21750>:
  monoeg_g_log (0B, 4, "pinned object %p has no gc descriptor", obj);
  <D.20221>:
  goto <D.20221>;
  <D.21751>:
  if (0 != 0) goto <D.21752>; else goto <D.21753>;
  <D.21752>:
  gc_debug_file.98 = gc_debug_file;
  fprintf (gc_debug_file.98, " (pinned, no change)\n");
  gc_debug_file.98 = gc_debug_file;
  fflush (gc_debug_file.98);
  <D.21753>:
  return;
  <D.21749>:
  D.21754 = copy_object_no_checks (obj, queue);
  *obj_slot = D.21754;
}


init_nursery (struct SgenFragmentAllocator * allocator, char * start, char * end)
{
  sgen_fragment_allocator_add (allocator, start, end);
}


build_fragments_finish (struct SgenFragmentAllocator * allocator)
{

}


build_fragments_release_exclude_head ()
{

}


build_fragments_get_exclude_head ()
{
  struct SgenFragment * D.21756;

  D.21756 = 0B;
  return D.21756;
}


clear_fragments ()
{

}


prepare_to_space (char * to_space_bitmap, int space_bitmap_size)
{

}


par_alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  char * D.21758;
  void * (*<T3846>) (struct MonoVTable *, int, gboolean) D.21759;
  int objsize.100;

  D.21759 = major_collector.par_alloc_object;
  objsize.100 = (int) objsize;
  D.21758 = D.21759 (vtable, objsize.100, has_references);
  return D.21758;
}


alloc_for_promotion (struct MonoVTable * vtable, char * obj, size_t objsize, gboolean has_references)
{
  char * D.21762;
  void * (*<T3846>) (struct MonoVTable *, int, gboolean) D.21763;
  int objsize.101;

  D.21763 = major_collector.alloc_object;
  objsize.101 = (int) objsize;
  D.21762 = D.21763 (vtable, objsize.101, has_references);
  return D.21762;
}