describe_ptr (char * ptr)
{
  describe_pointer (ptr, 1);
}


describe_pointer (char * ptr, gboolean need_setup)
{
  int D.18540;
  char * start.0;
  char * start.1;
  long unsigned int D.18547;
  long unsigned int D.18548;
  int D.18550;
  long int ptr.2;
  long int start.3;
  long int D.18558;
  int D.18559;
  gboolean (*<T2e59>) (char *, char * *) D.18561;
  int D.18562;
  struct MonoVTable * (*<T2e73>) (char *) D.18573;
  gboolean (*<T2dda>) (char *) D.18575;
  int D.18576;
  long unsigned int D.18580;
  char * iftmp.4;
  long unsigned int D.18584;
  int D.18592;
  struct MonoClass * D.18595;
  const char * D.18596;
  long int desc.5;
  int D.18598;
  const char * D.18599;
  unsigned int D.18600;
  int D.18601;
  struct MonoVTable * vtable;
  mword desc;
  int type;
  char * start;
  char * forwarded;
  mword size;
  void restart = <<< error >>>;
  void bridge = <<< error >>>;

  try
    {
      restart:
      D.18540 = sgen_ptr_in_nursery (ptr);
      if (D.18540 != 0) goto <D.18541>; else goto <D.18542>;
      <D.18541>:
      start.0 = describe_nursery_ptr (ptr, need_setup);
      start = start.0;
      start.1 = start;
      if (start.1 == 0B) goto <D.18545>; else goto <D.18546>;
      <D.18545>:
      return;
      <D.18546>:
      ptr = start;
      D.18547 = MEM[(mword *)ptr];
      D.18548 = D.18547 & 18446744073709551612;
      vtable = (struct MonoVTable *) D.18548;
      goto <D.18549>;
      <D.18542>:
      D.18550 = sgen_ptr_is_in_los (ptr, &start);
      if (D.18550 != 0) goto <D.18551>; else goto <D.18552>;
      <D.18551>:
      start.1 = start;
      if (ptr == start.1) goto <D.18553>; else goto <D.18554>;
      <D.18553>:
      start.1 = start;
      printf ("Pointer is the start of object %p in LOS space.\n", start.1);
      goto <D.18555>;
      <D.18554>:
      ptr.2 = (long int) ptr;
      start.1 = start;
      start.3 = (long int) start.1;
      D.18558 = ptr.2 - start.3;
      D.18559 = (int) D.18558;
      start.1 = start;
      printf ("Pointer is at offset 0x%x of object %p in LOS space.\n", D.18559, start.1);
      <D.18555>:
      ptr = start;
      mono_sgen_los_describe_pointer (ptr);
      D.18547 = MEM[(mword *)ptr];
      D.18548 = D.18547 & 18446744073709551612;
      vtable = (struct MonoVTable *) D.18548;
      goto <D.18560>;
      <D.18552>:
      D.18561 = major_collector.ptr_is_in_non_pinned_space;
      D.18562 = D.18561 (ptr, &start);
      if (D.18562 != 0) goto <D.18563>; else goto <D.18564>;
      <D.18563>:
      start.1 = start;
      if (ptr == start.1) goto <D.18565>; else goto <D.18566>;
      <D.18565>:
      start.1 = start;
      printf ("Pointer is the start of object %p in oldspace.\n", start.1);
      goto <D.18567>;
      <D.18566>:
      start.1 = start;
      if (start.1 != 0B) goto <D.18568>; else goto <D.18569>;
      <D.18568>:
      ptr.2 = (long int) ptr;
      start.1 = start;
      start.3 = (long int) start.1;
      D.18558 = ptr.2 - start.3;
      D.18559 = (int) D.18558;
      start.1 = start;
      printf ("Pointer is at offset 0x%x of object %p in oldspace.\n", D.18559, start.1);
      goto <D.18570>;
      <D.18569>:
      printf ("Pointer inside oldspace.\n");
      <D.18570>:
      <D.18567>:
      start.1 = start;
      if (start.1 != 0B) goto <D.18571>; else goto <D.18572>;
      <D.18571>:
      ptr = start;
      <D.18572>:
      D.18573 = major_collector.describe_pointer;
      vtable = D.18573 (ptr);
      goto <D.18574>;
      <D.18564>:
      D.18575 = major_collector.obj_is_from_pinned_alloc;
      D.18576 = D.18575 (ptr);
      if (D.18576 != 0) goto <D.18577>; else goto <D.18578>;
      <D.18577>:
      printf ("Pointer is inside a pinned chunk.\n");
      D.18547 = MEM[(mword *)ptr];
      D.18548 = D.18547 & 18446744073709551612;
      vtable = (struct MonoVTable *) D.18548;
      goto <D.18579>;
      <D.18578>:
      printf ("Pointer unknown.\n");
      return;
      <D.18579>:
      <D.18574>:
      <D.18560>:
      <D.18549>:
      D.18547 = MEM[(mword *)ptr];
      D.18580 = D.18547 & 2;
      if (D.18580 != 0) goto <D.18581>; else goto <D.18582>;
      <D.18581>:
      printf ("Object is pinned.\n");
      <D.18582>:
      D.18547 = MEM[(mword *)ptr];
      D.18584 = D.18547 & 1;
      if (D.18584 != 0) goto <D.18585>; else goto <D.18586>;
      <D.18585>:
      D.18547 = MEM[(mword *)ptr];
      D.18548 = D.18547 & 18446744073709551612;
      iftmp.4 = (char *) D.18548;
      goto <D.18587>;
      <D.18586>:
      iftmp.4 = 0B;
      <D.18587>:
      forwarded = iftmp.4;
      if (forwarded != 0B) goto <D.18588>; else goto <D.18589>;
      <D.18588>:
      printf ("Object is forwarded to %p:\n", forwarded);
      ptr = forwarded;
      goto restart;
      <D.18589>:
      printf ("VTable: %p\n", vtable);
      if (vtable == 0B) goto <D.18590>; else goto <D.18591>;
      <D.18590>:
      printf ("VTable is invalid (empty).\n");
      goto bridge;
      <D.18591>:
      D.18592 = sgen_ptr_in_nursery (vtable);
      if (D.18592 != 0) goto <D.18593>; else goto <D.18594>;
      <D.18593>:
      printf ("VTable is invalid (points inside nursery).\n");
      goto bridge;
      <D.18594>:
      D.18595 = vtable->klass;
      D.18596 = D.18595->name;
      printf ("Class: %s\n", D.18596);
      desc = MEM[(struct GCVTable *)vtable].desc;
      desc.5 = (long int) desc;
      printf ("Descriptor: %lx\n", desc.5);
      D.18598 = (int) desc;
      type = D.18598 & 7;
      D.18599 = descriptor_types[type];
      printf ("Descriptor type: %d (%s)\n", type, D.18599);
      D.18600 = sgen_safe_object_get_size (ptr);
      size = (mword) D.18600;
      D.18601 = (int) size;
      printf ("Size: %d\n", D.18601);
      bridge:
      sgen_bridge_describe_pointer (ptr);
    }
  finally
    {
      start = {CLOBBER};
    }
}


describe_nursery_ptr (char * ptr, gboolean need_setup)
{
  char * * valid_nursery_objects.6;
  long unsigned int D.18608;
  long unsigned int D.18609;
  char * * D.18610;
  char * D.18611;
  int valid_nursery_object_count.7;
  unsigned int D.18617;
  sizetype D.18618;
  char * D.18619;
  int gc_debug_level.8;
  _Bool D.18621;
  long int D.18622;
  long int D.18623;
  struct FILE * gc_debug_file.9;
  char * D.18627;
  long int ptr.10;
  long int obj.11;
  long int D.18637;
  int i;

  if (need_setup != 0) goto <D.18605>; else goto <D.18606>;
  <D.18605>:
  setup_valid_nursery_objects ();
  <D.18606>:
  i = 0;
  goto <D.18261>;
  <D.18260>:
  valid_nursery_objects.6 = valid_nursery_objects;
  D.18608 = (long unsigned int) i;
  D.18609 = D.18608 * 8;
  D.18610 = valid_nursery_objects.6 + D.18609;
  D.18611 = *D.18610;
  if (D.18611 >= ptr) goto <D.18259>; else goto <D.18612>;
  <D.18612>:
  i = i + 1;
  <D.18261>:
  valid_nursery_object_count.7 = valid_nursery_object_count;
  if (i < valid_nursery_object_count.7) goto <D.18260>; else goto <D.18259>;
  <D.18259>:
  valid_nursery_object_count.7 = valid_nursery_object_count;
  if (i >= valid_nursery_object_count.7) goto <D.18614>; else goto <D.18616>;
  <D.18616>:
  valid_nursery_objects.6 = valid_nursery_objects;
  D.18608 = (long unsigned int) i;
  D.18609 = D.18608 * 8;
  D.18610 = valid_nursery_objects.6 + D.18609;
  D.18611 = *D.18610;
  valid_nursery_objects.6 = valid_nursery_objects;
  D.18608 = (long unsigned int) i;
  D.18609 = D.18608 * 8;
  D.18610 = valid_nursery_objects.6 + D.18609;
  D.18611 = *D.18610;
  D.18617 = sgen_safe_object_get_size (D.18611);
  D.18618 = (sizetype) D.18617;
  D.18619 = D.18611 + D.18618;
  if (D.18619 < ptr) goto <D.18614>; else goto <D.18615>;
  <D.18614>:
  gc_debug_level.8 = gc_debug_level;
  D.18621 = gc_debug_level.8 >= 0;
  D.18622 = (long int) D.18621;
  D.18623 = __builtin_expect (D.18622, 0);
  if (D.18623 != 0) goto <D.18624>; else goto <D.18625>;
  <D.18624>:
  gc_debug_file.9 = gc_debug_file;
  fprintf (gc_debug_file.9, "nursery-ptr (unalloc\'d-memory)\n\n");
  gc_debug_file.9 = gc_debug_file;
  fflush (gc_debug_file.9);
  <D.18625>:
  D.18627 = 0B;
  return D.18627;
  <D.18615>:
  {
    char * obj;

    valid_nursery_objects.6 = valid_nursery_objects;
    D.18608 = (long unsigned int) i;
    D.18609 = D.18608 * 8;
    D.18610 = valid_nursery_objects.6 + D.18609;
    obj = *D.18610;
    if (obj == ptr) goto <D.18628>; else goto <D.18629>;
    <D.18628>:
    gc_debug_level.8 = gc_debug_level;
    D.18621 = gc_debug_level.8 >= 0;
    D.18622 = (long int) D.18621;
    D.18623 = __builtin_expect (D.18622, 0);
    if (D.18623 != 0) goto <D.18630>; else goto <D.18631>;
    <D.18630>:
    gc_debug_file.9 = gc_debug_file;
    fprintf (gc_debug_file.9, "nursery-ptr\n\n");
    gc_debug_file.9 = gc_debug_file;
    fflush (gc_debug_file.9);
    <D.18631>:
    goto <D.18632>;
    <D.18629>:
    gc_debug_level.8 = gc_debug_level;
    D.18621 = gc_debug_level.8 >= 0;
    D.18622 = (long int) D.18621;
    D.18623 = __builtin_expect (D.18622, 0);
    if (D.18623 != 0) goto <D.18633>; else goto <D.18634>;
    <D.18633>:
    gc_debug_file.9 = gc_debug_file;
    ptr.10 = (long int) ptr;
    obj.11 = (long int) obj;
    D.18637 = ptr.10 - obj.11;
    fprintf (gc_debug_file.9, "nursery-ptr (interior-ptr offset %td)\n\n", D.18637);
    gc_debug_file.9 = gc_debug_file;
    fflush (gc_debug_file.9);
    <D.18634>:
    <D.18632>:
    D.18627 = obj;
    return D.18627;
  }
}


setup_valid_nursery_objects ()
{
  char * * valid_nursery_objects.12;
  int sgen_nursery_size.13;
  long unsigned int D.18643;
  void * D.18644;
  struct GCMemSection * nursery_section.14;
  char * D.18646;
  char * D.18647;

  valid_nursery_objects.12 = valid_nursery_objects;
  if (valid_nursery_objects.12 == 0B) goto <D.18640>; else goto <D.18641>;
  <D.18640>:
  sgen_nursery_size.13 = sgen_nursery_size;
  D.18643 = (long unsigned int) sgen_nursery_size.13;
  D.18644 = sgen_alloc_os_memory (D.18643, 2, "debugging data");
  valid_nursery_objects = D.18644;
  <D.18641>:
  valid_nursery_object_count = 0;
  nursery_section.14 = nursery_section;
  D.18646 = nursery_section.14->data;
  nursery_section.14 = nursery_section;
  D.18647 = nursery_section.14->end_data;
  sgen_scan_area_with_callback (D.18646, D.18647, setup_mono_sgen_scan_area_with_callback, 0B, 0);
}


setup_mono_sgen_scan_area_with_callback (char * object, size_t size, void * data)
{
  char * * valid_nursery_objects.15;
  int valid_nursery_object_count.16;
  int valid_nursery_object_count.17;
  int D.18651;
  long unsigned int D.18652;
  long unsigned int D.18653;
  char * * D.18654;

  valid_nursery_objects.15 = valid_nursery_objects;
  valid_nursery_object_count.16 = valid_nursery_object_count;
  valid_nursery_object_count.17 = valid_nursery_object_count.16;
  D.18651 = valid_nursery_object_count.17 + 1;
  valid_nursery_object_count = D.18651;
  D.18652 = (long unsigned int) valid_nursery_object_count.17;
  D.18653 = D.18652 * 8;
  D.18654 = valid_nursery_objects.15 + D.18653;
  *D.18654 = object;
}


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

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


__attribute__((always_inline))
sgen_ptr_in_nursery (void * p)
{
  gboolean D.18657;
  int sgen_nursery_bits.18;
  int D.18659;
  int D.18660;
  long unsigned int D.18661;
  long unsigned int p.19;
  long unsigned int D.18663;
  char * sgen_nursery_start.20;
  long unsigned int sgen_nursery_start.21;
  _Bool D.18666;

  sgen_nursery_bits.18 = sgen_nursery_bits;
  D.18659 = 1 << sgen_nursery_bits.18;
  D.18660 = -D.18659;
  D.18661 = (long unsigned int) D.18660;
  p.19 = (long unsigned int) p;
  D.18663 = D.18661 & p.19;
  sgen_nursery_start.20 = sgen_nursery_start;
  sgen_nursery_start.21 = (long unsigned int) sgen_nursery_start.20;
  D.18666 = D.18663 == sgen_nursery_start.21;
  D.18657 = (gboolean) D.18666;
  return D.18657;
}


sgen_safe_object_get_size (struct MonoObject * obj)
{
  char * iftmp.22;
  long unsigned int D.18669;
  long unsigned int D.18670;
  long unsigned int D.18673;
  guint D.18677;
  struct MonoVTable * D.18678;
  char * forwarded;

  D.18669 = MEM[(mword *)obj];
  D.18670 = D.18669 & 1;
  if (D.18670 != 0) goto <D.18671>; else goto <D.18672>;
  <D.18671>:
  D.18669 = MEM[(mword *)obj];
  D.18673 = D.18669 & 18446744073709551612;
  iftmp.22 = (char *) D.18673;
  goto <D.18674>;
  <D.18672>:
  iftmp.22 = 0B;
  <D.18674>:
  forwarded = iftmp.22;
  if (forwarded != 0B) goto <D.18675>; else goto <D.18676>;
  <D.18675>:
  obj = forwarded;
  <D.18676>:
  D.18669 = MEM[(mword *)obj];
  D.18673 = D.18669 & 18446744073709551612;
  D.18678 = (struct MonoVTable *) D.18673;
  D.18677 = sgen_par_object_get_size (D.18678, obj);
  return D.18677;
}


sgen_par_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  void * D.18680;
  long unsigned int D.18681;
  guint D.18686;
  int D.18687;
  int D.18688;
  unsigned int D.18689;
  long unsigned int D.18692;
  int D.18693;
  unsigned int D.18694;
  unsigned int element_size.23;
  unsigned int D.18696;
  long unsigned int D.18697;
  long unsigned int D.18698;
  struct MonoClass * D.18701;
  unsigned char D.18702;
  long unsigned int D.18703;
  long unsigned int D.18704;
  mword descr;
  mword type;

  D.18680 = vtable->gc_descr;
  descr = (mword) D.18680;
  type = descr & 7;
  D.18681 = type + 18446744073709551615;
  if (D.18681 <= 1) goto <D.18682>; else goto <D.18683>;
  <D.18682>:
  {
    mword size;

    size = descr & 65528;
    if (size == 0) goto <D.18684>; else goto <D.18685>;
    <D.18684>:
    D.18687 = MEM[(struct MonoString *)o].length;
    D.18688 = D.18687 * 2;
    D.18689 = (unsigned int) D.18688;
    D.18686 = D.18689 + 26;
    return D.18686;
    <D.18685>:
    D.18686 = (guint) size;
    return D.18686;
  }
  <D.18683>:
  if (type == 4) goto <D.18690>; else goto <D.18691>;
  <D.18690>:
  {
    int element_size;
    struct MonoArray * array;
    size_t size;

    D.18692 = descr >> 3;
    D.18693 = (int) D.18692;
    element_size = D.18693 & 1023;
    array = o;
    D.18694 = array->max_length;
    element_size.23 = (unsigned int) element_size;
    D.18696 = D.18694 * element_size.23;
    D.18697 = (long unsigned int) D.18696;
    size = D.18697 + 32;
    D.18698 = descr & 8192;
    if (D.18698 != 0) goto <D.18699>; else goto <D.18700>;
    <D.18699>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.18701 = vtable->klass;
    D.18702 = D.18701->rank;
    D.18703 = (long unsigned int) D.18702;
    D.18704 = D.18703 * 8;
    size = D.18704 + size;
    <D.18700>:
    D.18686 = (guint) size;
    return D.18686;
  }
  <D.18691>:
  D.18686 = slow_object_get_size (vtable, o);
  return D.18686;
}


slow_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  struct MonoClass * D.18706;
  guint D.18709;
  int D.18710;
  int D.18711;
  unsigned int D.18712;
  unsigned char D.18713;
  int D.18716;
  unsigned int D.18717;
  unsigned int D.18718;
  unsigned int D.18719;
  long unsigned int D.18720;
  struct MonoArrayBounds * D.18721;
  _Bool D.18722;
  long int D.18723;
  long int D.18724;
  long unsigned int D.18727;
  long unsigned int D.18728;
  int D.18729;
  struct MonoClass * klass;

  klass = vtable->klass;
  D.18706 = mono_defaults.string_class;
  if (D.18706 == klass) goto <D.18707>; else goto <D.18708>;
  <D.18707>:
  D.18710 = MEM[(struct MonoString *)o].length;
  D.18711 = D.18710 * 2;
  D.18712 = (unsigned int) D.18711;
  D.18709 = D.18712 + 26;
  return D.18709;
  <D.18708>:
  D.18713 = klass->rank;
  if (D.18713 != 0) goto <D.18714>; else goto <D.18715>;
  <D.18714>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.18716 = klass->sizes.element_size;
    D.18717 = (unsigned int) D.18716;
    D.18718 = array->max_length;
    D.18719 = D.18717 * D.18718;
    D.18720 = (long unsigned int) D.18719;
    size = D.18720 + 32;
    D.18721 = array->bounds;
    D.18722 = D.18721 != 0B;
    D.18723 = (long int) D.18722;
    D.18724 = __builtin_expect (D.18723, 0);
    if (D.18724 != 0) goto <D.18725>; else goto <D.18726>;
    <D.18725>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.18713 = klass->rank;
    D.18727 = (long unsigned int) D.18713;
    D.18728 = D.18727 * 8;
    size = D.18728 + size;
    <D.18726>:
    D.18709 = (guint) size;
    return D.18709;
  }
  <D.18715>:
  D.18729 = klass->instance_size;
  D.18709 = (guint) D.18729;
  return D.18709;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.18731;

  D.18731 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.18731;
}


sgen_check_consistency ()
{
  int gc_debug_level.24;
  _Bool D.18734;
  long int D.18735;
  long int D.18736;
  struct FILE * gc_debug_file.25;
  void (*<T2e34>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.18740;
  int missing_remsets.26;
  _Bool D.18746;
  long int D.18747;
  long int D.18748;

  missing_remsets = 0;
  gc_debug_level.24 = gc_debug_level;
  D.18734 = gc_debug_level.24 > 0;
  D.18735 = (long int) D.18734;
  D.18736 = __builtin_expect (D.18735, 0);
  if (D.18736 != 0) goto <D.18737>; else goto <D.18738>;
  <D.18737>:
  gc_debug_file.25 = gc_debug_file;
  fprintf (gc_debug_file.25, "Begin heap consistency check...\n");
  gc_debug_file.25 = gc_debug_file;
  fflush (gc_debug_file.25);
  <D.18738>:
  D.18740 = major_collector.iterate_objects;
  D.18740 (1, 1, check_consistency_callback, 0B);
  sgen_los_iterate_objects (check_consistency_callback, 0B);
  gc_debug_level.24 = gc_debug_level;
  D.18734 = gc_debug_level.24 > 0;
  D.18735 = (long int) D.18734;
  D.18736 = __builtin_expect (D.18735, 0);
  if (D.18736 != 0) goto <D.18741>; else goto <D.18742>;
  <D.18741>:
  gc_debug_file.25 = gc_debug_file;
  fprintf (gc_debug_file.25, "Heap consistency check done.\n");
  gc_debug_file.25 = gc_debug_file;
  fflush (gc_debug_file.25);
  <D.18742>:
  if (1 != 0) goto <D.18743>; else goto <D.18744>;
  <D.18743>:
  missing_remsets.26 = missing_remsets;
  D.18746 = missing_remsets.26 != 0;
  D.18747 = (long int) D.18746;
  D.18748 = __builtin_expect (D.18747, 0);
  if (D.18748 != 0) goto <D.18749>; else goto <D.18750>;
  <D.18749>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 204, "!missing_remsets");
  <D.18750>:
  <D.18744>:
}


check_consistency_callback (char * start, size_t size, void * dummy)
{
  long unsigned int D.18751;
  long unsigned int D.18752;
  struct FILE * gc_debug_file.27;
  struct MonoClass * D.18756;
  const char * D.18757;
  long unsigned int D.18758;
  long unsigned int D.18759;
  long unsigned int D.18762;
  long unsigned int D.18763;
  long unsigned int D.18764;
  long unsigned int D.18765;
  long unsigned int D.18766;
  long unsigned int D.18767;
  void * D.18768;
  int D.18771;
  struct SgenRemeberedSet * D.18774;
  gboolean (*<T2dda>) (char *) D.18775;
  int D.18776;
  int gc_debug_level.28;
  _Bool D.18780;
  long int D.18781;
  long int D.18782;
  long int _objptr.29;
  long int start.30;
  long int D.18787;
  struct MonoVTable * D.18788;
  struct MonoClass * D.18789;
  const char * D.18790;
  const char * D.18791;
  long unsigned int D.18792;
  long unsigned int D.18793;
  int D.18798;
  struct SgenRemeberedSet * D.18801;
  gboolean (*<T2dda>) (char *) D.18802;
  int D.18803;
  long unsigned int D.18810;
  long unsigned int D.18811;
  int D.18812;
  void * D.18813;
  int D.18816;
  struct SgenRemeberedSet * D.18819;
  gboolean (*<T2dda>) (char *) D.18820;
  int D.18821;
  long int _objptr.31;
  long int D.18827;
  long unsigned int D.18828;
  long unsigned int D.18829;
  long unsigned int D.18832;
  long unsigned int D.18833;
  int D.18834;
  int D.18837;
  struct SgenRemeberedSet * D.18840;
  gboolean (*<T2dda>) (char *) D.18841;
  int D.18842;
  long unsigned int D.18849;
  long unsigned int D.18852;
  int D.18853;
  int D.18854;
  unsigned int D.18857;
  unsigned int el_size.32;
  unsigned int D.18859;
  sizetype D.18860;
  void * D.18861;
  int D.18864;
  struct SgenRemeberedSet * D.18867;
  gboolean (*<T2dda>) (char *) D.18868;
  int D.18869;
  long int p.33;
  long int D.18875;
  long unsigned int D.18876;
  long unsigned int D.18877;
  int D.18883;
  int D.18884;
  long unsigned int D.18885;
  long unsigned int D.18886;
  long unsigned int D.18887;
  long unsigned int D.18888;
  void * * D.18889;
  void * D.18890;
  int D.18893;
  struct SgenRemeberedSet * D.18896;
  gboolean (*<T2dda>) (char *) D.18897;
  int D.18898;
  long int D.18903;
  long int D.18904;
  long unsigned int D.18905;
  long unsigned int D.18906;
  sizetype D.18909;
  long unsigned int D.18913;
  void * D.18916;
  int D.18919;
  struct SgenRemeberedSet * D.18922;
  gboolean (*<T2dda>) (char *) D.18923;
  int D.18924;
  long int p.34;
  long int D.18930;
  long unsigned int D.18931;
  long unsigned int D.18932;
  long unsigned int D.18935;
  void * D.18938;
  int D.18941;
  struct SgenRemeberedSet * D.18944;
  gboolean (*<T2dda>) (char *) D.18945;
  int D.18946;
  long int _objptr.35;
  long int D.18952;
  long unsigned int D.18953;
  long unsigned int D.18954;
  long unsigned int D.18957;
  unsigned int D.18958;
  unsigned int D.18959;
  struct MonoVTable * D.18962;
  struct MonoClass * D.18963;
  const char * D.18964;
  const char * D.18965;
  gsize * bitmap_data.36;
  long unsigned int D.18967;
  void * D.18970;
  int D.18973;
  struct SgenRemeberedSet * D.18976;
  gboolean (*<T2dda>) (char *) D.18977;
  int D.18978;
  long int _objptr.37;
  long int D.18984;
  long unsigned int D.18985;
  long unsigned int D.18986;
  int bwords.38;
  long unsigned int D.18990;
  gsize * mbitmap_data.39;
  long unsigned int D.18992;
  unsigned int D.18993;
  unsigned int D.18994;
  struct MonoClass * D.18995;
  unsigned int el_size.40;
  unsigned int D.18997;
  sizetype D.18998;
  const char * D.19001;
  const char * D.19002;
  gsize * bitmap_data.41;
  long unsigned int D.19004;
  void * D.19007;
  int D.19010;
  struct SgenRemeberedSet * D.19013;
  gboolean (*<T2dda>) (char *) D.19014;
  int D.19015;
  long int _objptr.42;
  long int D.19021;
  long unsigned int D.19022;
  long unsigned int D.19023;
  unsigned int bwords.43;
  sizetype D.19027;
  struct GCVTable * vt;

  D.18751 = MEM[(mword *)start];
  D.18752 = D.18751 & 18446744073709551612;
  vt = (struct GCVTable *) D.18752;
  if (0 != 0) goto <D.18753>; else goto <D.18754>;
  <D.18753>:
  gc_debug_file.27 = gc_debug_file;
  D.18756 = vt->klass;
  D.18757 = D.18756->name;
  fprintf (gc_debug_file.27, "Scanning object %p, vtable: %p (%s)\n", start, vt, D.18757);
  gc_debug_file.27 = gc_debug_file;
  fflush (gc_debug_file.27);
  <D.18754>:
  {
    struct GCVTable * vt;
    mword desc;

    D.18751 = MEM[(mword *)start];
    D.18752 = D.18751 & 18446744073709551612;
    vt = (struct GCVTable *) D.18752;
    desc = vt->desc;
    D.18758 = desc & 7;
    switch (D.18758) <default: <D.17930>, case 1: <D.17845>, case 2: <D.17852>, case 3: <D.17896>, case 4: <D.17860>, case 5: <D.17890>, case 6: <D.17909>, case 7: <D.17929>>
    <D.17845>:
    D.18759 = desc & 4294901760;
    if (D.18759 != 0) goto <D.18760>; else goto <D.18761>;
    <D.18760>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.18762 = desc >> 16;
      D.18763 = D.18762 & 255;
      D.18764 = D.18763 * 8;
      _objptr = _objptr + D.18764;
      D.18765 = desc >> 24;
      D.18766 = D.18765 & 255;
      D.18767 = D.18766 * 8;
      _objptr_end = _objptr + D.18767;
      D.18768 = *_objptr;
      if (D.18768 != 0B) goto <D.18769>; else goto <D.18770>;
      <D.18769>:
      D.18768 = *_objptr;
      D.18771 = sgen_ptr_in_nursery (D.18768);
      if (D.18771 != 0) goto <D.18772>; else goto <D.18773>;
      <D.18772>:
      D.18774 = sgen_get_remset ();
      D.18775 = D.18774->find_address;
      D.18776 = D.18775 (_objptr);
      if (D.18776 == 0) goto <D.18777>; else goto <D.18778>;
      <D.18777>:
      gc_debug_level.28 = gc_debug_level;
      D.18780 = gc_debug_level.28 >= 0;
      D.18781 = (long int) D.18780;
      D.18782 = __builtin_expect (D.18781, 0);
      if (D.18782 != 0) goto <D.18783>; else goto <D.18784>;
      <D.18783>:
      gc_debug_file.27 = gc_debug_file;
      D.18768 = *_objptr;
      _objptr.29 = (long int) _objptr;
      start.30 = (long int) start;
      D.18787 = _objptr.29 - start.30;
      D.18788 = MEM[(struct MonoObject *)start].vtable;
      D.18789 = D.18788->klass;
      D.18790 = D.18789->name_space;
      D.18788 = MEM[(struct MonoObject *)start].vtable;
      D.18789 = D.18788->klass;
      D.18791 = D.18789->name;
      fprintf (gc_debug_file.27, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18768, D.18787, start, D.18790, D.18791);
      gc_debug_file.27 = gc_debug_file;
      fflush (gc_debug_file.27);
      <D.18784>:
      D.18768 = *_objptr;
      D.18792 = MEM[(mword *)D.18768];
      D.18793 = D.18792 & 2;
      if (D.18793 == 0) goto <D.18794>; else goto <D.18795>;
      <D.18794>:
      missing_remsets = 1;
      <D.18795>:
      <D.18778>:
      <D.18773>:
      <D.18770>:
      _objptr = _objptr + 8;
      goto <D.17849>;
      <D.17848>:
      D.18768 = *_objptr;
      if (D.18768 != 0B) goto <D.18796>; else goto <D.18797>;
      <D.18796>:
      D.18768 = *_objptr;
      D.18798 = sgen_ptr_in_nursery (D.18768);
      if (D.18798 != 0) goto <D.18799>; else goto <D.18800>;
      <D.18799>:
      D.18801 = sgen_get_remset ();
      D.18802 = D.18801->find_address;
      D.18803 = D.18802 (_objptr);
      if (D.18803 == 0) goto <D.18804>; else goto <D.18805>;
      <D.18804>:
      gc_debug_level.28 = gc_debug_level;
      D.18780 = gc_debug_level.28 >= 0;
      D.18781 = (long int) D.18780;
      D.18782 = __builtin_expect (D.18781, 0);
      if (D.18782 != 0) goto <D.18806>; else goto <D.18807>;
      <D.18806>:
      gc_debug_file.27 = gc_debug_file;
      D.18768 = *_objptr;
      _objptr.29 = (long int) _objptr;
      start.30 = (long int) start;
      D.18787 = _objptr.29 - start.30;
      D.18788 = MEM[(struct MonoObject *)start].vtable;
      D.18789 = D.18788->klass;
      D.18790 = D.18789->name_space;
      D.18788 = MEM[(struct MonoObject *)start].vtable;
      D.18789 = D.18788->klass;
      D.18791 = D.18789->name;
      fprintf (gc_debug_file.27, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18768, D.18787, start, D.18790, D.18791);
      gc_debug_file.27 = gc_debug_file;
      fflush (gc_debug_file.27);
      <D.18807>:
      D.18768 = *_objptr;
      D.18792 = MEM[(mword *)D.18768];
      D.18793 = D.18792 & 2;
      if (D.18793 == 0) goto <D.18808>; else goto <D.18809>;
      <D.18808>:
      missing_remsets = 1;
      <D.18809>:
      <D.18805>:
      <D.18800>:
      <D.18797>:
      _objptr = _objptr + 8;
      <D.17849>:
      if (_objptr < _objptr_end) goto <D.17848>; else goto <D.17850>;
      <D.17850>:
    }
    <D.18761>:
    goto <D.17851>;
    <D.17852>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.18810 = (long unsigned int) _index;
        D.18811 = D.18810 * 8;
        _objptr = _objptr + D.18811;
        D.18812 = _index + 1;
        _bmap = _bmap >> D.18812;
        D.18813 = *_objptr;
        if (D.18813 != 0B) goto <D.18814>; else goto <D.18815>;
        <D.18814>:
        D.18813 = *_objptr;
        D.18816 = sgen_ptr_in_nursery (D.18813);
        if (D.18816 != 0) goto <D.18817>; else goto <D.18818>;
        <D.18817>:
        D.18819 = sgen_get_remset ();
        D.18820 = D.18819->find_address;
        D.18821 = D.18820 (_objptr);
        if (D.18821 == 0) goto <D.18822>; else goto <D.18823>;
        <D.18822>:
        gc_debug_level.28 = gc_debug_level;
        D.18780 = gc_debug_level.28 >= 0;
        D.18781 = (long int) D.18780;
        D.18782 = __builtin_expect (D.18781, 0);
        if (D.18782 != 0) goto <D.18824>; else goto <D.18825>;
        <D.18824>:
        gc_debug_file.27 = gc_debug_file;
        D.18813 = *_objptr;
        _objptr.31 = (long int) _objptr;
        start.30 = (long int) start;
        D.18827 = _objptr.31 - start.30;
        D.18788 = MEM[(struct MonoObject *)start].vtable;
        D.18789 = D.18788->klass;
        D.18790 = D.18789->name_space;
        D.18788 = MEM[(struct MonoObject *)start].vtable;
        D.18789 = D.18788->klass;
        D.18791 = D.18789->name;
        fprintf (gc_debug_file.27, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18813, D.18827, start, D.18790, D.18791);
        gc_debug_file.27 = gc_debug_file;
        fflush (gc_debug_file.27);
        <D.18825>:
        D.18813 = *_objptr;
        D.18828 = MEM[(mword *)D.18813];
        D.18829 = D.18828 & 2;
        if (D.18829 == 0) goto <D.18830>; else goto <D.18831>;
        <D.18830>:
        missing_remsets = 1;
        <D.18831>:
        <D.18823>:
        <D.18818>:
        <D.18815>:
        _objptr = _objptr + 8;
      }
      goto <D.17858>;
      <D.17857>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.18832 = (long unsigned int) _index;
        D.18833 = D.18832 * 8;
        _objptr = _objptr + D.18833;
        D.18834 = _index + 1;
        _bmap = _bmap >> D.18834;
        D.18813 = *_objptr;
        if (D.18813 != 0B) goto <D.18835>; else goto <D.18836>;
        <D.18835>:
        D.18813 = *_objptr;
        D.18837 = sgen_ptr_in_nursery (D.18813);
        if (D.18837 != 0) goto <D.18838>; else goto <D.18839>;
        <D.18838>:
        D.18840 = sgen_get_remset ();
        D.18841 = D.18840->find_address;
        D.18842 = D.18841 (_objptr);
        if (D.18842 == 0) goto <D.18843>; else goto <D.18844>;
        <D.18843>:
        gc_debug_level.28 = gc_debug_level;
        D.18780 = gc_debug_level.28 >= 0;
        D.18781 = (long int) D.18780;
        D.18782 = __builtin_expect (D.18781, 0);
        if (D.18782 != 0) goto <D.18845>; else goto <D.18846>;
        <D.18845>:
        gc_debug_file.27 = gc_debug_file;
        D.18813 = *_objptr;
        _objptr.31 = (long int) _objptr;
        start.30 = (long int) start;
        D.18827 = _objptr.31 - start.30;
        D.18788 = MEM[(struct MonoObject *)start].vtable;
        D.18789 = D.18788->klass;
        D.18790 = D.18789->name_space;
        D.18788 = MEM[(struct MonoObject *)start].vtable;
        D.18789 = D.18788->klass;
        D.18791 = D.18789->name;
        fprintf (gc_debug_file.27, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18813, D.18827, start, D.18790, D.18791);
        gc_debug_file.27 = gc_debug_file;
        fflush (gc_debug_file.27);
        <D.18846>:
        D.18813 = *_objptr;
        D.18828 = MEM[(mword *)D.18813];
        D.18829 = D.18828 & 2;
        if (D.18829 == 0) goto <D.18847>; else goto <D.18848>;
        <D.18847>:
        missing_remsets = 1;
        <D.18848>:
        <D.18844>:
        <D.18839>:
        <D.18836>:
        _objptr = _objptr + 8;
      }
      <D.17858>:
      if (_bmap != 0) goto <D.17857>; else goto <D.17859>;
      <D.17859>:
    }
    goto <D.17851>;
    <D.17860>:
    D.18849 = desc & 4294950912;
    if (D.18849 != 0) goto <D.18850>; else goto <D.18851>;
    <D.18850>:
    {
      int el_size;
      int etype;

      D.18852 = desc >> 3;
      D.18853 = (int) D.18852;
      el_size = D.18853 & 1023;
      D.18854 = (int) desc;
      etype = D.18854 & 49152;
      if (etype == 16384) goto <D.18855>; else goto <D.18856>;
      <D.18855>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.18857 = MEM[(struct MonoArray *)start].max_length;
        el_size.32 = (unsigned int) el_size;
        D.18859 = D.18857 * el_size.32;
        D.18860 = (sizetype) D.18859;
        end_refs = p + D.18860;
        goto <D.17866>;
        <D.17865>:
        D.18861 = *p;
        if (D.18861 != 0B) goto <D.18862>; else goto <D.18863>;
        <D.18862>:
        D.18861 = *p;
        D.18864 = sgen_ptr_in_nursery (D.18861);
        if (D.18864 != 0) goto <D.18865>; else goto <D.18866>;
        <D.18865>:
        D.18867 = sgen_get_remset ();
        D.18868 = D.18867->find_address;
        D.18869 = D.18868 (p);
        if (D.18869 == 0) goto <D.18870>; else goto <D.18871>;
        <D.18870>:
        gc_debug_level.28 = gc_debug_level;
        D.18780 = gc_debug_level.28 >= 0;
        D.18781 = (long int) D.18780;
        D.18782 = __builtin_expect (D.18781, 0);
        if (D.18782 != 0) goto <D.18872>; else goto <D.18873>;
        <D.18872>:
        gc_debug_file.27 = gc_debug_file;
        D.18861 = *p;
        p.33 = (long int) p;
        start.30 = (long int) start;
        D.18875 = p.33 - start.30;
        D.18788 = MEM[(struct MonoObject *)start].vtable;
        D.18789 = D.18788->klass;
        D.18790 = D.18789->name_space;
        D.18788 = MEM[(struct MonoObject *)start].vtable;
        D.18789 = D.18788->klass;
        D.18791 = D.18789->name;
        fprintf (gc_debug_file.27, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18861, D.18875, start, D.18790, D.18791);
        gc_debug_file.27 = gc_debug_file;
        fflush (gc_debug_file.27);
        <D.18873>:
        D.18861 = *p;
        D.18876 = MEM[(mword *)D.18861];
        D.18877 = D.18876 & 2;
        if (D.18877 == 0) goto <D.18878>; else goto <D.18879>;
        <D.18878>:
        missing_remsets = 1;
        <D.18879>:
        <D.18871>:
        <D.18866>:
        <D.18863>:
        p = p + 8;
        <D.17866>:
        if (p < end_refs) goto <D.17865>; else goto <D.17867>;
        <D.17867>:
      }
      goto <D.18880>;
      <D.18856>:
      if (etype == 32768) goto <D.18881>; else goto <D.18882>;
      <D.18881>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.18762 = desc >> 16;
        D.18883 = (int) D.18762;
        offset = D.18883 & 255;
        D.18765 = desc >> 24;
        D.18884 = (int) D.18765;
        num_refs = D.18884 & 255;
        e_start = start + 32;
        D.18857 = MEM[(struct MonoArray *)start].max_length;
        el_size.32 = (unsigned int) el_size;
        D.18859 = D.18857 * el_size.32;
        D.18860 = (sizetype) D.18859;
        e_end = e_start + D.18860;
        goto <D.17878>;
        <D.17877>:
        {
          void * * p;
          int i;

          p = e_start;
          D.18885 = (long unsigned int) offset;
          D.18886 = D.18885 * 8;
          p = p + D.18886;
          i = 0;
          goto <D.17875>;
          <D.17874>:
          D.18887 = (long unsigned int) i;
          D.18888 = D.18887 * 8;
          D.18889 = p + D.18888;
          D.18890 = *D.18889;
          if (D.18890 != 0B) goto <D.18891>; else goto <D.18892>;
          <D.18891>:
          D.18887 = (long unsigned int) i;
          D.18888 = D.18887 * 8;
          D.18889 = p + D.18888;
          D.18890 = *D.18889;
          D.18893 = sgen_ptr_in_nursery (D.18890);
          if (D.18893 != 0) goto <D.18894>; else goto <D.18895>;
          <D.18894>:
          D.18896 = sgen_get_remset ();
          D.18897 = D.18896->find_address;
          D.18887 = (long unsigned int) i;
          D.18888 = D.18887 * 8;
          D.18889 = p + D.18888;
          D.18898 = D.18897 (D.18889);
          if (D.18898 == 0) goto <D.18899>; else goto <D.18900>;
          <D.18899>:
          gc_debug_level.28 = gc_debug_level;
          D.18780 = gc_debug_level.28 >= 0;
          D.18781 = (long int) D.18780;
          D.18782 = __builtin_expect (D.18781, 0);
          if (D.18782 != 0) goto <D.18901>; else goto <D.18902>;
          <D.18901>:
          gc_debug_file.27 = gc_debug_file;
          D.18887 = (long unsigned int) i;
          D.18888 = D.18887 * 8;
          D.18889 = p + D.18888;
          D.18890 = *D.18889;
          D.18887 = (long unsigned int) i;
          D.18888 = D.18887 * 8;
          D.18889 = p + D.18888;
          D.18903 = (long int) D.18889;
          start.30 = (long int) start;
          D.18904 = D.18903 - start.30;
          D.18788 = MEM[(struct MonoObject *)start].vtable;
          D.18789 = D.18788->klass;
          D.18790 = D.18789->name_space;
          D.18788 = MEM[(struct MonoObject *)start].vtable;
          D.18789 = D.18788->klass;
          D.18791 = D.18789->name;
          fprintf (gc_debug_file.27, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18890, D.18904, start, D.18790, D.18791);
          gc_debug_file.27 = gc_debug_file;
          fflush (gc_debug_file.27);
          <D.18902>:
          D.18887 = (long unsigned int) i;
          D.18888 = D.18887 * 8;
          D.18889 = p + D.18888;
          D.18890 = *D.18889;
          D.18905 = MEM[(mword *)D.18890];
          D.18906 = D.18905 & 2;
          if (D.18906 == 0) goto <D.18907>; else goto <D.18908>;
          <D.18907>:
          missing_remsets = 1;
          <D.18908>:
          <D.18900>:
          <D.18895>:
          <D.18892>:
          i = i + 1;
          <D.17875>:
          if (i < num_refs) goto <D.17874>; else goto <D.17876>;
          <D.17876>:
          D.18909 = (sizetype) el_size;
          e_start = e_start + D.18909;
        }
        <D.17878>:
        if (e_start < e_end) goto <D.17877>; else goto <D.17879>;
        <D.17879>:
      }
      goto <D.18910>;
      <D.18882>:
      if (etype == 49152) goto <D.18911>; else goto <D.18912>;
      <D.18911>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.18857 = MEM[(struct MonoArray *)start].max_length;
        el_size.32 = (unsigned int) el_size;
        D.18859 = D.18857 * el_size.32;
        D.18860 = (sizetype) D.18859;
        e_end = e_start + D.18860;
        goto <D.17888>;
        <D.17887>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17885>;
          <D.17884>:
          D.18913 = _bmap & 1;
          if (D.18913 != 0) goto <D.18914>; else goto <D.18915>;
          <D.18914>:
          D.18916 = *p;
          if (D.18916 != 0B) goto <D.18917>; else goto <D.18918>;
          <D.18917>:
          D.18916 = *p;
          D.18919 = sgen_ptr_in_nursery (D.18916);
          if (D.18919 != 0) goto <D.18920>; else goto <D.18921>;
          <D.18920>:
          D.18922 = sgen_get_remset ();
          D.18923 = D.18922->find_address;
          D.18924 = D.18923 (p);
          if (D.18924 == 0) goto <D.18925>; else goto <D.18926>;
          <D.18925>:
          gc_debug_level.28 = gc_debug_level;
          D.18780 = gc_debug_level.28 >= 0;
          D.18781 = (long int) D.18780;
          D.18782 = __builtin_expect (D.18781, 0);
          if (D.18782 != 0) goto <D.18927>; else goto <D.18928>;
          <D.18927>:
          gc_debug_file.27 = gc_debug_file;
          D.18916 = *p;
          p.34 = (long int) p;
          start.30 = (long int) start;
          D.18930 = p.34 - start.30;
          D.18788 = MEM[(struct MonoObject *)start].vtable;
          D.18789 = D.18788->klass;
          D.18790 = D.18789->name_space;
          D.18788 = MEM[(struct MonoObject *)start].vtable;
          D.18789 = D.18788->klass;
          D.18791 = D.18789->name;
          fprintf (gc_debug_file.27, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18916, D.18930, start, D.18790, D.18791);
          gc_debug_file.27 = gc_debug_file;
          fflush (gc_debug_file.27);
          <D.18928>:
          D.18916 = *p;
          D.18931 = MEM[(mword *)D.18916];
          D.18932 = D.18931 & 2;
          if (D.18932 == 0) goto <D.18933>; else goto <D.18934>;
          <D.18933>:
          missing_remsets = 1;
          <D.18934>:
          <D.18926>:
          <D.18921>:
          <D.18918>:
          <D.18915>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.17885>:
          if (_bmap != 0) goto <D.17884>; else goto <D.17886>;
          <D.17886>:
          D.18909 = (sizetype) el_size;
          e_start = e_start + D.18909;
        }
        <D.17888>:
        if (e_start < e_end) goto <D.17887>; else goto <D.17889>;
        <D.17889>:
      }
      <D.18912>:
      <D.18910>:
      <D.18880>:
    }
    <D.18851>:
    goto <D.17851>;
    <D.17890>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.17894>;
      <D.17893>:
      D.18935 = _bmap & 1;
      if (D.18935 != 0) goto <D.18936>; else goto <D.18937>;
      <D.18936>:
      D.18938 = *_objptr;
      if (D.18938 != 0B) goto <D.18939>; else goto <D.18940>;
      <D.18939>:
      D.18938 = *_objptr;
      D.18941 = sgen_ptr_in_nursery (D.18938);
      if (D.18941 != 0) goto <D.18942>; else goto <D.18943>;
      <D.18942>:
      D.18944 = sgen_get_remset ();
      D.18945 = D.18944->find_address;
      D.18946 = D.18945 (_objptr);
      if (D.18946 == 0) goto <D.18947>; else goto <D.18948>;
      <D.18947>:
      gc_debug_level.28 = gc_debug_level;
      D.18780 = gc_debug_level.28 >= 0;
      D.18781 = (long int) D.18780;
      D.18782 = __builtin_expect (D.18781, 0);
      if (D.18782 != 0) goto <D.18949>; else goto <D.18950>;
      <D.18949>:
      gc_debug_file.27 = gc_debug_file;
      D.18938 = *_objptr;
      _objptr.35 = (long int) _objptr;
      start.30 = (long int) start;
      D.18952 = _objptr.35 - start.30;
      D.18788 = MEM[(struct MonoObject *)start].vtable;
      D.18789 = D.18788->klass;
      D.18790 = D.18789->name_space;
      D.18788 = MEM[(struct MonoObject *)start].vtable;
      D.18789 = D.18788->klass;
      D.18791 = D.18789->name;
      fprintf (gc_debug_file.27, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18938, D.18952, start, D.18790, D.18791);
      gc_debug_file.27 = gc_debug_file;
      fflush (gc_debug_file.27);
      <D.18950>:
      D.18938 = *_objptr;
      D.18953 = MEM[(mword *)D.18938];
      D.18954 = D.18953 & 2;
      if (D.18954 == 0) goto <D.18955>; else goto <D.18956>;
      <D.18955>:
      missing_remsets = 1;
      <D.18956>:
      <D.18948>:
      <D.18943>:
      <D.18940>:
      <D.18937>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.17894>:
      if (_bmap != 0) goto <D.17893>; else goto <D.17895>;
      <D.17895>:
    }
    goto <D.17851>;
    <D.17896>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.18957 = *bitmap_data;
      D.18958 = (unsigned int) D.18957;
      D.18959 = D.18958 + 4294967295;
      bwords = (int) D.18959;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.18960>; else goto <D.18961>;
      <D.18960>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.18962 = myobj->vtable;
        D.18963 = D.18962->klass;
        D.18964 = D.18963->name_space;
        D.18962 = myobj->vtable;
        D.18963 = D.18962->klass;
        D.18965 = D.18963->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18964, D.18965);
      }
      <D.18961>:
      goto <D.17907>;
      <D.17906>:
      {
        gsize _bmap;

        bitmap_data.36 = bitmap_data;
        bitmap_data = bitmap_data.36 + 8;
        _bmap = *bitmap_data.36;
        _objptr = start_run;
        goto <D.17904>;
        <D.17903>:
        D.18967 = _bmap & 1;
        if (D.18967 != 0) goto <D.18968>; else goto <D.18969>;
        <D.18968>:
        D.18970 = *_objptr;
        if (D.18970 != 0B) goto <D.18971>; else goto <D.18972>;
        <D.18971>:
        D.18970 = *_objptr;
        D.18973 = sgen_ptr_in_nursery (D.18970);
        if (D.18973 != 0) goto <D.18974>; else goto <D.18975>;
        <D.18974>:
        D.18976 = sgen_get_remset ();
        D.18977 = D.18976->find_address;
        D.18978 = D.18977 (_objptr);
        if (D.18978 == 0) goto <D.18979>; else goto <D.18980>;
        <D.18979>:
        gc_debug_level.28 = gc_debug_level;
        D.18780 = gc_debug_level.28 >= 0;
        D.18781 = (long int) D.18780;
        D.18782 = __builtin_expect (D.18781, 0);
        if (D.18782 != 0) goto <D.18981>; else goto <D.18982>;
        <D.18981>:
        gc_debug_file.27 = gc_debug_file;
        D.18970 = *_objptr;
        _objptr.37 = (long int) _objptr;
        start.30 = (long int) start;
        D.18984 = _objptr.37 - start.30;
        D.18788 = MEM[(struct MonoObject *)start].vtable;
        D.18789 = D.18788->klass;
        D.18790 = D.18789->name_space;
        D.18788 = MEM[(struct MonoObject *)start].vtable;
        D.18789 = D.18788->klass;
        D.18791 = D.18789->name;
        fprintf (gc_debug_file.27, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18970, D.18984, start, D.18790, D.18791);
        gc_debug_file.27 = gc_debug_file;
        fflush (gc_debug_file.27);
        <D.18982>:
        D.18970 = *_objptr;
        D.18985 = MEM[(mword *)D.18970];
        D.18986 = D.18985 & 2;
        if (D.18986 == 0) goto <D.18987>; else goto <D.18988>;
        <D.18987>:
        missing_remsets = 1;
        <D.18988>:
        <D.18980>:
        <D.18975>:
        <D.18972>:
        <D.18969>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.17904>:
        if (_bmap != 0) goto <D.17903>; else goto <D.17905>;
        <D.17905>:
        start_run = start_run + 512;
      }
      <D.17907>:
      bwords.38 = bwords;
      bwords = bwords.38 + -1;
      if (bwords.38 > 0) goto <D.17906>; else goto <D.17908>;
      <D.17908>:
    }
    goto <D.17851>;
    <D.17909>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.18990 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.18990);
      mbitmap_data.39 = mbitmap_data;
      mbitmap_data = mbitmap_data.39 + 8;
      D.18992 = *mbitmap_data.39;
      D.18993 = (unsigned int) D.18992;
      D.18994 = D.18993 + 4294967295;
      mbwords = (int) D.18994;
      D.18995 = vt->klass;
      el_size = mono_array_element_size (D.18995);
      e_start = start + 32;
      D.18857 = MEM[(struct MonoArray *)start].max_length;
      el_size.40 = (unsigned int) el_size;
      D.18997 = D.18857 * el_size.40;
      D.18998 = (sizetype) D.18997;
      e_end = e_start + D.18998;
      if (0 != 0) goto <D.18999>; else goto <D.19000>;
      <D.18999>:
      D.18990 = vt->desc;
      D.18995 = vt->klass;
      D.19001 = D.18995->name_space;
      D.18995 = vt->klass;
      D.19002 = D.18995->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.18990, D.19001, D.19002);
      <D.19000>:
      goto <D.17927>;
      <D.17926>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.41 = bitmap_data;
          bitmap_data = bitmap_data.41 + 8;
          _bmap = *bitmap_data.41;
          start_run = _objptr;
          goto <D.17921>;
          <D.17920>:
          D.19004 = _bmap & 1;
          if (D.19004 != 0) goto <D.19005>; else goto <D.19006>;
          <D.19005>:
          D.19007 = *_objptr;
          if (D.19007 != 0B) goto <D.19008>; else goto <D.19009>;
          <D.19008>:
          D.19007 = *_objptr;
          D.19010 = sgen_ptr_in_nursery (D.19007);
          if (D.19010 != 0) goto <D.19011>; else goto <D.19012>;
          <D.19011>:
          D.19013 = sgen_get_remset ();
          D.19014 = D.19013->find_address;
          D.19015 = D.19014 (_objptr);
          if (D.19015 == 0) goto <D.19016>; else goto <D.19017>;
          <D.19016>:
          gc_debug_level.28 = gc_debug_level;
          D.18780 = gc_debug_level.28 >= 0;
          D.18781 = (long int) D.18780;
          D.18782 = __builtin_expect (D.18781, 0);
          if (D.18782 != 0) goto <D.19018>; else goto <D.19019>;
          <D.19018>:
          gc_debug_file.27 = gc_debug_file;
          D.19007 = *_objptr;
          _objptr.42 = (long int) _objptr;
          start.30 = (long int) start;
          D.19021 = _objptr.42 - start.30;
          D.18788 = MEM[(struct MonoObject *)start].vtable;
          D.18789 = D.18788->klass;
          D.18790 = D.18789->name_space;
          D.18788 = MEM[(struct MonoObject *)start].vtable;
          D.18789 = D.18788->klass;
          D.18791 = D.18789->name;
          fprintf (gc_debug_file.27, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.19007, D.19021, start, D.18790, D.18791);
          gc_debug_file.27 = gc_debug_file;
          fflush (gc_debug_file.27);
          <D.19019>:
          D.19007 = *_objptr;
          D.19022 = MEM[(mword *)D.19007];
          D.19023 = D.19022 & 2;
          if (D.19023 == 0) goto <D.19024>; else goto <D.19025>;
          <D.19024>:
          missing_remsets = 1;
          <D.19025>:
          <D.19017>:
          <D.19012>:
          <D.19009>:
          <D.19006>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.17921>:
          if (_bmap != 0) goto <D.17920>; else goto <D.17922>;
          <D.17922>:
          _objptr = start_run + 512;
        }
        <D.17924>:
        bwords.43 = bwords;
        bwords = bwords.43 + 4294967295;
        if (bwords.43 != 0) goto <D.17923>; else goto <D.17925>;
        <D.17925>:
        D.19027 = (sizetype) el_size;
        e_start = e_start + D.19027;
      }
      <D.17927>:
      if (e_start < e_end) goto <D.17926>; else goto <D.17928>;
      <D.17928>:
    }
    goto <D.17851>;
    <D.17929>:
    goto <D.17851>;
    <D.17930>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17851>:
  }
}


sgen_check_mod_union_consistency ()
{
  void (*<T2e34>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.19029;
  int missing_remsets.44;
  _Bool D.19033;
  long int D.19034;
  long int D.19035;

  missing_remsets = 0;
  D.19029 = major_collector.iterate_objects;
  D.19029 (1, 1, check_mod_union_callback, 0B);
  sgen_los_iterate_objects (check_mod_union_callback, 1B);
  if (1 != 0) goto <D.19030>; else goto <D.19031>;
  <D.19030>:
  missing_remsets.44 = missing_remsets;
  D.19033 = missing_remsets.44 != 0;
  D.19034 = (long int) D.19033;
  D.19035 = __builtin_expect (D.19034, 0);
  if (D.19035 != 0) goto <D.19036>; else goto <D.19037>;
  <D.19036>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 258, "!missing_remsets");
  <D.19037>:
  <D.19031>:
}


check_mod_union_callback (char * start, size_t size, void * dummy)
{
  long int dummy.45;
  long unsigned int D.19039;
  long unsigned int D.19040;
  struct FILE * gc_debug_file.46;
  struct MonoClass * D.19044;
  const char * D.19045;
  int D.19046;
  struct LOSObject * D.19051;
  struct SgenMajorCollector * D.19053;
  guint8 * (*<T2e77>) (char *) D.19054;
  _Bool D.19055;
  long int D.19056;
  long int D.19057;
  long unsigned int D.19060;
  long unsigned int D.19061;
  long unsigned int D.19064;
  long unsigned int D.19065;
  long unsigned int D.19066;
  long unsigned int D.19067;
  long unsigned int D.19068;
  long unsigned int D.19069;
  void * D.19070;
  int D.19073;
  int D.19076;
  struct SgenRemeberedSet * D.19079;
  gboolean (*<T2eb6>) (char *, guint8 *, char *) D.19080;
  int D.19081;
  int gc_debug_level.47;
  _Bool D.19085;
  long int D.19086;
  long int D.19087;
  long int _objptr.48;
  long int start.49;
  long int D.19092;
  struct MonoVTable * D.19093;
  struct MonoClass * D.19094;
  const char * D.19095;
  const char * D.19096;
  int D.19099;
  int D.19102;
  struct SgenRemeberedSet * D.19105;
  gboolean (*<T2eb6>) (char *, guint8 *, char *) D.19106;
  int D.19107;
  long unsigned int D.19112;
  long unsigned int D.19113;
  int D.19114;
  void * D.19115;
  int D.19118;
  int D.19121;
  struct SgenRemeberedSet * D.19124;
  gboolean (*<T2eb6>) (char *, guint8 *, char *) D.19125;
  int D.19126;
  long int _objptr.50;
  long int D.19132;
  long unsigned int D.19133;
  long unsigned int D.19134;
  int D.19135;
  int D.19138;
  int D.19141;
  struct SgenRemeberedSet * D.19144;
  gboolean (*<T2eb6>) (char *, guint8 *, char *) D.19145;
  int D.19146;
  long unsigned int D.19151;
  long unsigned int D.19154;
  int D.19155;
  int D.19156;
  unsigned int D.19159;
  unsigned int el_size.51;
  unsigned int D.19161;
  sizetype D.19162;
  void * D.19163;
  int D.19166;
  int D.19169;
  struct SgenRemeberedSet * D.19172;
  gboolean (*<T2eb6>) (char *, guint8 *, char *) D.19173;
  int D.19174;
  long int p.52;
  long int D.19180;
  int D.19184;
  int D.19185;
  long unsigned int D.19186;
  long unsigned int D.19187;
  long unsigned int D.19188;
  long unsigned int D.19189;
  void * * D.19190;
  void * D.19191;
  int D.19194;
  int D.19197;
  struct SgenRemeberedSet * D.19200;
  gboolean (*<T2eb6>) (char *, guint8 *, char *) D.19201;
  int D.19202;
  long int D.19207;
  long int D.19208;
  sizetype D.19209;
  long unsigned int D.19213;
  void * D.19216;
  int D.19219;
  int D.19222;
  struct SgenRemeberedSet * D.19225;
  gboolean (*<T2eb6>) (char *, guint8 *, char *) D.19226;
  int D.19227;
  long int p.53;
  long int D.19233;
  long unsigned int D.19234;
  void * D.19237;
  int D.19240;
  int D.19243;
  struct SgenRemeberedSet * D.19246;
  gboolean (*<T2eb6>) (char *, guint8 *, char *) D.19247;
  int D.19248;
  long int _objptr.54;
  long int D.19254;
  long unsigned int D.19255;
  unsigned int D.19256;
  unsigned int D.19257;
  struct MonoVTable * D.19260;
  struct MonoClass * D.19261;
  const char * D.19262;
  const char * D.19263;
  gsize * bitmap_data.55;
  long unsigned int D.19265;
  void * D.19268;
  int D.19271;
  int D.19274;
  struct SgenRemeberedSet * D.19277;
  gboolean (*<T2eb6>) (char *, guint8 *, char *) D.19278;
  int D.19279;
  long int _objptr.56;
  long int D.19285;
  int bwords.57;
  long unsigned int D.19287;
  gsize * mbitmap_data.58;
  long unsigned int D.19289;
  unsigned int D.19290;
  unsigned int D.19291;
  struct MonoClass * D.19292;
  unsigned int el_size.59;
  unsigned int D.19294;
  sizetype D.19295;
  const char * D.19298;
  const char * D.19299;
  gsize * bitmap_data.60;
  long unsigned int D.19301;
  void * D.19304;
  int D.19307;
  int D.19310;
  struct SgenRemeberedSet * D.19313;
  gboolean (*<T2eb6>) (char *, guint8 *, char *) D.19314;
  int D.19315;
  long int _objptr.61;
  long int D.19321;
  unsigned int bwords.62;
  sizetype D.19323;
  gboolean in_los;
  struct GCVTable * vt;
  guint8 * cards;

  dummy.45 = (long int) dummy;
  in_los = (gboolean) dummy.45;
  D.19039 = MEM[(mword *)start];
  D.19040 = D.19039 & 18446744073709551612;
  vt = (struct GCVTable *) D.19040;
  if (0 != 0) goto <D.19041>; else goto <D.19042>;
  <D.19041>:
  gc_debug_file.46 = gc_debug_file;
  D.19044 = vt->klass;
  D.19045 = D.19044->name;
  fprintf (gc_debug_file.46, "Scanning object %p, vtable: %p (%s)\n", start, vt, D.19045);
  gc_debug_file.46 = gc_debug_file;
  fflush (gc_debug_file.46);
  <D.19042>:
  D.19046 = is_major_or_los_object_marked (start);
  if (D.19046 == 0) goto <D.19047>; else goto <D.19048>;
  <D.19047>:
  return;
  <D.19048>:
  if (in_los != 0) goto <D.19049>; else goto <D.19050>;
  <D.19049>:
  D.19051 = sgen_los_header_for_object (start);
  cards = D.19051->cardtable_mod_union;
  goto <D.19052>;
  <D.19050>:
  D.19053 = sgen_get_major_collector ();
  D.19054 = D.19053->get_cardtable_mod_union_for_object;
  cards = D.19054 (start);
  <D.19052>:
  D.19055 = cards == 0B;
  D.19056 = (long int) D.19055;
  D.19057 = __builtin_expect (D.19056, 0);
  if (D.19057 != 0) goto <D.19058>; else goto <D.19059>;
  <D.19058>:
  monoeg_g_log (0B, 4, "we must have mod union for marked major objects");
  <D.17945>:
  goto <D.17945>;
  <D.19059>:
  {
    struct GCVTable * vt;
    mword desc;

    D.19039 = MEM[(mword *)start];
    D.19040 = D.19039 & 18446744073709551612;
    vt = (struct GCVTable *) D.19040;
    desc = vt->desc;
    D.19060 = desc & 7;
    switch (D.19060) <default: <D.18033>, case 1: <D.17948>, case 2: <D.17955>, case 3: <D.17999>, case 4: <D.17963>, case 5: <D.17993>, case 6: <D.18012>, case 7: <D.18032>>
    <D.17948>:
    D.19061 = desc & 4294901760;
    if (D.19061 != 0) goto <D.19062>; else goto <D.19063>;
    <D.19062>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19064 = desc >> 16;
      D.19065 = D.19064 & 255;
      D.19066 = D.19065 * 8;
      _objptr = _objptr + D.19066;
      D.19067 = desc >> 24;
      D.19068 = D.19067 & 255;
      D.19069 = D.19068 * 8;
      _objptr_end = _objptr + D.19069;
      D.19070 = *_objptr;
      if (D.19070 != 0B) goto <D.19071>; else goto <D.19072>;
      <D.19071>:
      D.19070 = *_objptr;
      D.19073 = sgen_ptr_in_nursery (D.19070);
      if (D.19073 == 0) goto <D.19074>; else goto <D.19075>;
      <D.19074>:
      D.19070 = *_objptr;
      D.19076 = is_major_or_los_object_marked (D.19070);
      if (D.19076 == 0) goto <D.19077>; else goto <D.19078>;
      <D.19077>:
      D.19079 = sgen_get_remset ();
      D.19080 = D.19079->find_address_with_cards;
      D.19081 = D.19080 (start, cards, _objptr);
      if (D.19081 == 0) goto <D.19082>; else goto <D.19083>;
      <D.19082>:
      gc_debug_level.47 = gc_debug_level;
      D.19085 = gc_debug_level.47 >= 0;
      D.19086 = (long int) D.19085;
      D.19087 = __builtin_expect (D.19086, 0);
      if (D.19087 != 0) goto <D.19088>; else goto <D.19089>;
      <D.19088>:
      gc_debug_file.46 = gc_debug_file;
      D.19070 = *_objptr;
      _objptr.48 = (long int) _objptr;
      start.49 = (long int) start;
      D.19092 = _objptr.48 - start.49;
      D.19093 = MEM[(struct MonoObject *)start].vtable;
      D.19094 = D.19093->klass;
      D.19095 = D.19094->name_space;
      D.19093 = MEM[(struct MonoObject *)start].vtable;
      D.19094 = D.19093->klass;
      D.19096 = D.19094->name;
      fprintf (gc_debug_file.46, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.19070, D.19092, start, D.19095, D.19096);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19089>:
      <D.19083>:
      <D.19078>:
      <D.19075>:
      <D.19072>:
      _objptr = _objptr + 8;
      goto <D.17952>;
      <D.17951>:
      D.19070 = *_objptr;
      if (D.19070 != 0B) goto <D.19097>; else goto <D.19098>;
      <D.19097>:
      D.19070 = *_objptr;
      D.19099 = sgen_ptr_in_nursery (D.19070);
      if (D.19099 == 0) goto <D.19100>; else goto <D.19101>;
      <D.19100>:
      D.19070 = *_objptr;
      D.19102 = is_major_or_los_object_marked (D.19070);
      if (D.19102 == 0) goto <D.19103>; else goto <D.19104>;
      <D.19103>:
      D.19105 = sgen_get_remset ();
      D.19106 = D.19105->find_address_with_cards;
      D.19107 = D.19106 (start, cards, _objptr);
      if (D.19107 == 0) goto <D.19108>; else goto <D.19109>;
      <D.19108>:
      gc_debug_level.47 = gc_debug_level;
      D.19085 = gc_debug_level.47 >= 0;
      D.19086 = (long int) D.19085;
      D.19087 = __builtin_expect (D.19086, 0);
      if (D.19087 != 0) goto <D.19110>; else goto <D.19111>;
      <D.19110>:
      gc_debug_file.46 = gc_debug_file;
      D.19070 = *_objptr;
      _objptr.48 = (long int) _objptr;
      start.49 = (long int) start;
      D.19092 = _objptr.48 - start.49;
      D.19093 = MEM[(struct MonoObject *)start].vtable;
      D.19094 = D.19093->klass;
      D.19095 = D.19094->name_space;
      D.19093 = MEM[(struct MonoObject *)start].vtable;
      D.19094 = D.19093->klass;
      D.19096 = D.19094->name;
      fprintf (gc_debug_file.46, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.19070, D.19092, start, D.19095, D.19096);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19111>:
      <D.19109>:
      <D.19104>:
      <D.19101>:
      <D.19098>:
      _objptr = _objptr + 8;
      <D.17952>:
      if (_objptr < _objptr_end) goto <D.17951>; else goto <D.17953>;
      <D.17953>:
    }
    <D.19063>:
    goto <D.17954>;
    <D.17955>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.19112 = (long unsigned int) _index;
        D.19113 = D.19112 * 8;
        _objptr = _objptr + D.19113;
        D.19114 = _index + 1;
        _bmap = _bmap >> D.19114;
        D.19115 = *_objptr;
        if (D.19115 != 0B) goto <D.19116>; else goto <D.19117>;
        <D.19116>:
        D.19115 = *_objptr;
        D.19118 = sgen_ptr_in_nursery (D.19115);
        if (D.19118 == 0) goto <D.19119>; else goto <D.19120>;
        <D.19119>:
        D.19115 = *_objptr;
        D.19121 = is_major_or_los_object_marked (D.19115);
        if (D.19121 == 0) goto <D.19122>; else goto <D.19123>;
        <D.19122>:
        D.19124 = sgen_get_remset ();
        D.19125 = D.19124->find_address_with_cards;
        D.19126 = D.19125 (start, cards, _objptr);
        if (D.19126 == 0) goto <D.19127>; else goto <D.19128>;
        <D.19127>:
        gc_debug_level.47 = gc_debug_level;
        D.19085 = gc_debug_level.47 >= 0;
        D.19086 = (long int) D.19085;
        D.19087 = __builtin_expect (D.19086, 0);
        if (D.19087 != 0) goto <D.19129>; else goto <D.19130>;
        <D.19129>:
        gc_debug_file.46 = gc_debug_file;
        D.19115 = *_objptr;
        _objptr.50 = (long int) _objptr;
        start.49 = (long int) start;
        D.19132 = _objptr.50 - start.49;
        D.19093 = MEM[(struct MonoObject *)start].vtable;
        D.19094 = D.19093->klass;
        D.19095 = D.19094->name_space;
        D.19093 = MEM[(struct MonoObject *)start].vtable;
        D.19094 = D.19093->klass;
        D.19096 = D.19094->name;
        fprintf (gc_debug_file.46, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.19115, D.19132, start, D.19095, D.19096);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19130>:
        <D.19128>:
        <D.19123>:
        <D.19120>:
        <D.19117>:
        _objptr = _objptr + 8;
      }
      goto <D.17961>;
      <D.17960>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.19133 = (long unsigned int) _index;
        D.19134 = D.19133 * 8;
        _objptr = _objptr + D.19134;
        D.19135 = _index + 1;
        _bmap = _bmap >> D.19135;
        D.19115 = *_objptr;
        if (D.19115 != 0B) goto <D.19136>; else goto <D.19137>;
        <D.19136>:
        D.19115 = *_objptr;
        D.19138 = sgen_ptr_in_nursery (D.19115);
        if (D.19138 == 0) goto <D.19139>; else goto <D.19140>;
        <D.19139>:
        D.19115 = *_objptr;
        D.19141 = is_major_or_los_object_marked (D.19115);
        if (D.19141 == 0) goto <D.19142>; else goto <D.19143>;
        <D.19142>:
        D.19144 = sgen_get_remset ();
        D.19145 = D.19144->find_address_with_cards;
        D.19146 = D.19145 (start, cards, _objptr);
        if (D.19146 == 0) goto <D.19147>; else goto <D.19148>;
        <D.19147>:
        gc_debug_level.47 = gc_debug_level;
        D.19085 = gc_debug_level.47 >= 0;
        D.19086 = (long int) D.19085;
        D.19087 = __builtin_expect (D.19086, 0);
        if (D.19087 != 0) goto <D.19149>; else goto <D.19150>;
        <D.19149>:
        gc_debug_file.46 = gc_debug_file;
        D.19115 = *_objptr;
        _objptr.50 = (long int) _objptr;
        start.49 = (long int) start;
        D.19132 = _objptr.50 - start.49;
        D.19093 = MEM[(struct MonoObject *)start].vtable;
        D.19094 = D.19093->klass;
        D.19095 = D.19094->name_space;
        D.19093 = MEM[(struct MonoObject *)start].vtable;
        D.19094 = D.19093->klass;
        D.19096 = D.19094->name;
        fprintf (gc_debug_file.46, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.19115, D.19132, start, D.19095, D.19096);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19150>:
        <D.19148>:
        <D.19143>:
        <D.19140>:
        <D.19137>:
        _objptr = _objptr + 8;
      }
      <D.17961>:
      if (_bmap != 0) goto <D.17960>; else goto <D.17962>;
      <D.17962>:
    }
    goto <D.17954>;
    <D.17963>:
    D.19151 = desc & 4294950912;
    if (D.19151 != 0) goto <D.19152>; else goto <D.19153>;
    <D.19152>:
    {
      int el_size;
      int etype;

      D.19154 = desc >> 3;
      D.19155 = (int) D.19154;
      el_size = D.19155 & 1023;
      D.19156 = (int) desc;
      etype = D.19156 & 49152;
      if (etype == 16384) goto <D.19157>; else goto <D.19158>;
      <D.19157>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.19159 = MEM[(struct MonoArray *)start].max_length;
        el_size.51 = (unsigned int) el_size;
        D.19161 = D.19159 * el_size.51;
        D.19162 = (sizetype) D.19161;
        end_refs = p + D.19162;
        goto <D.17969>;
        <D.17968>:
        D.19163 = *p;
        if (D.19163 != 0B) goto <D.19164>; else goto <D.19165>;
        <D.19164>:
        D.19163 = *p;
        D.19166 = sgen_ptr_in_nursery (D.19163);
        if (D.19166 == 0) goto <D.19167>; else goto <D.19168>;
        <D.19167>:
        D.19163 = *p;
        D.19169 = is_major_or_los_object_marked (D.19163);
        if (D.19169 == 0) goto <D.19170>; else goto <D.19171>;
        <D.19170>:
        D.19172 = sgen_get_remset ();
        D.19173 = D.19172->find_address_with_cards;
        D.19174 = D.19173 (start, cards, p);
        if (D.19174 == 0) goto <D.19175>; else goto <D.19176>;
        <D.19175>:
        gc_debug_level.47 = gc_debug_level;
        D.19085 = gc_debug_level.47 >= 0;
        D.19086 = (long int) D.19085;
        D.19087 = __builtin_expect (D.19086, 0);
        if (D.19087 != 0) goto <D.19177>; else goto <D.19178>;
        <D.19177>:
        gc_debug_file.46 = gc_debug_file;
        D.19163 = *p;
        p.52 = (long int) p;
        start.49 = (long int) start;
        D.19180 = p.52 - start.49;
        D.19093 = MEM[(struct MonoObject *)start].vtable;
        D.19094 = D.19093->klass;
        D.19095 = D.19094->name_space;
        D.19093 = MEM[(struct MonoObject *)start].vtable;
        D.19094 = D.19093->klass;
        D.19096 = D.19094->name;
        fprintf (gc_debug_file.46, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.19163, D.19180, start, D.19095, D.19096);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19178>:
        <D.19176>:
        <D.19171>:
        <D.19168>:
        <D.19165>:
        p = p + 8;
        <D.17969>:
        if (p < end_refs) goto <D.17968>; else goto <D.17970>;
        <D.17970>:
      }
      goto <D.19181>;
      <D.19158>:
      if (etype == 32768) goto <D.19182>; else goto <D.19183>;
      <D.19182>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19064 = desc >> 16;
        D.19184 = (int) D.19064;
        offset = D.19184 & 255;
        D.19067 = desc >> 24;
        D.19185 = (int) D.19067;
        num_refs = D.19185 & 255;
        e_start = start + 32;
        D.19159 = MEM[(struct MonoArray *)start].max_length;
        el_size.51 = (unsigned int) el_size;
        D.19161 = D.19159 * el_size.51;
        D.19162 = (sizetype) D.19161;
        e_end = e_start + D.19162;
        goto <D.17981>;
        <D.17980>:
        {
          void * * p;
          int i;

          p = e_start;
          D.19186 = (long unsigned int) offset;
          D.19187 = D.19186 * 8;
          p = p + D.19187;
          i = 0;
          goto <D.17978>;
          <D.17977>:
          D.19188 = (long unsigned int) i;
          D.19189 = D.19188 * 8;
          D.19190 = p + D.19189;
          D.19191 = *D.19190;
          if (D.19191 != 0B) goto <D.19192>; else goto <D.19193>;
          <D.19192>:
          D.19188 = (long unsigned int) i;
          D.19189 = D.19188 * 8;
          D.19190 = p + D.19189;
          D.19191 = *D.19190;
          D.19194 = sgen_ptr_in_nursery (D.19191);
          if (D.19194 == 0) goto <D.19195>; else goto <D.19196>;
          <D.19195>:
          D.19188 = (long unsigned int) i;
          D.19189 = D.19188 * 8;
          D.19190 = p + D.19189;
          D.19191 = *D.19190;
          D.19197 = is_major_or_los_object_marked (D.19191);
          if (D.19197 == 0) goto <D.19198>; else goto <D.19199>;
          <D.19198>:
          D.19200 = sgen_get_remset ();
          D.19201 = D.19200->find_address_with_cards;
          D.19188 = (long unsigned int) i;
          D.19189 = D.19188 * 8;
          D.19190 = p + D.19189;
          D.19202 = D.19201 (start, cards, D.19190);
          if (D.19202 == 0) goto <D.19203>; else goto <D.19204>;
          <D.19203>:
          gc_debug_level.47 = gc_debug_level;
          D.19085 = gc_debug_level.47 >= 0;
          D.19086 = (long int) D.19085;
          D.19087 = __builtin_expect (D.19086, 0);
          if (D.19087 != 0) goto <D.19205>; else goto <D.19206>;
          <D.19205>:
          gc_debug_file.46 = gc_debug_file;
          D.19188 = (long unsigned int) i;
          D.19189 = D.19188 * 8;
          D.19190 = p + D.19189;
          D.19191 = *D.19190;
          D.19188 = (long unsigned int) i;
          D.19189 = D.19188 * 8;
          D.19190 = p + D.19189;
          D.19207 = (long int) D.19190;
          start.49 = (long int) start;
          D.19208 = D.19207 - start.49;
          D.19093 = MEM[(struct MonoObject *)start].vtable;
          D.19094 = D.19093->klass;
          D.19095 = D.19094->name_space;
          D.19093 = MEM[(struct MonoObject *)start].vtable;
          D.19094 = D.19093->klass;
          D.19096 = D.19094->name;
          fprintf (gc_debug_file.46, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.19191, D.19208, start, D.19095, D.19096);
          gc_debug_file.46 = gc_debug_file;
          fflush (gc_debug_file.46);
          <D.19206>:
          <D.19204>:
          <D.19199>:
          <D.19196>:
          <D.19193>:
          i = i + 1;
          <D.17978>:
          if (i < num_refs) goto <D.17977>; else goto <D.17979>;
          <D.17979>:
          D.19209 = (sizetype) el_size;
          e_start = e_start + D.19209;
        }
        <D.17981>:
        if (e_start < e_end) goto <D.17980>; else goto <D.17982>;
        <D.17982>:
      }
      goto <D.19210>;
      <D.19183>:
      if (etype == 49152) goto <D.19211>; else goto <D.19212>;
      <D.19211>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.19159 = MEM[(struct MonoArray *)start].max_length;
        el_size.51 = (unsigned int) el_size;
        D.19161 = D.19159 * el_size.51;
        D.19162 = (sizetype) D.19161;
        e_end = e_start + D.19162;
        goto <D.17991>;
        <D.17990>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17988>;
          <D.17987>:
          D.19213 = _bmap & 1;
          if (D.19213 != 0) goto <D.19214>; else goto <D.19215>;
          <D.19214>:
          D.19216 = *p;
          if (D.19216 != 0B) goto <D.19217>; else goto <D.19218>;
          <D.19217>:
          D.19216 = *p;
          D.19219 = sgen_ptr_in_nursery (D.19216);
          if (D.19219 == 0) goto <D.19220>; else goto <D.19221>;
          <D.19220>:
          D.19216 = *p;
          D.19222 = is_major_or_los_object_marked (D.19216);
          if (D.19222 == 0) goto <D.19223>; else goto <D.19224>;
          <D.19223>:
          D.19225 = sgen_get_remset ();
          D.19226 = D.19225->find_address_with_cards;
          D.19227 = D.19226 (start, cards, p);
          if (D.19227 == 0) goto <D.19228>; else goto <D.19229>;
          <D.19228>:
          gc_debug_level.47 = gc_debug_level;
          D.19085 = gc_debug_level.47 >= 0;
          D.19086 = (long int) D.19085;
          D.19087 = __builtin_expect (D.19086, 0);
          if (D.19087 != 0) goto <D.19230>; else goto <D.19231>;
          <D.19230>:
          gc_debug_file.46 = gc_debug_file;
          D.19216 = *p;
          p.53 = (long int) p;
          start.49 = (long int) start;
          D.19233 = p.53 - start.49;
          D.19093 = MEM[(struct MonoObject *)start].vtable;
          D.19094 = D.19093->klass;
          D.19095 = D.19094->name_space;
          D.19093 = MEM[(struct MonoObject *)start].vtable;
          D.19094 = D.19093->klass;
          D.19096 = D.19094->name;
          fprintf (gc_debug_file.46, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.19216, D.19233, start, D.19095, D.19096);
          gc_debug_file.46 = gc_debug_file;
          fflush (gc_debug_file.46);
          <D.19231>:
          <D.19229>:
          <D.19224>:
          <D.19221>:
          <D.19218>:
          <D.19215>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.17988>:
          if (_bmap != 0) goto <D.17987>; else goto <D.17989>;
          <D.17989>:
          D.19209 = (sizetype) el_size;
          e_start = e_start + D.19209;
        }
        <D.17991>:
        if (e_start < e_end) goto <D.17990>; else goto <D.17992>;
        <D.17992>:
      }
      <D.19212>:
      <D.19210>:
      <D.19181>:
    }
    <D.19153>:
    goto <D.17954>;
    <D.17993>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.17997>;
      <D.17996>:
      D.19234 = _bmap & 1;
      if (D.19234 != 0) goto <D.19235>; else goto <D.19236>;
      <D.19235>:
      D.19237 = *_objptr;
      if (D.19237 != 0B) goto <D.19238>; else goto <D.19239>;
      <D.19238>:
      D.19237 = *_objptr;
      D.19240 = sgen_ptr_in_nursery (D.19237);
      if (D.19240 == 0) goto <D.19241>; else goto <D.19242>;
      <D.19241>:
      D.19237 = *_objptr;
      D.19243 = is_major_or_los_object_marked (D.19237);
      if (D.19243 == 0) goto <D.19244>; else goto <D.19245>;
      <D.19244>:
      D.19246 = sgen_get_remset ();
      D.19247 = D.19246->find_address_with_cards;
      D.19248 = D.19247 (start, cards, _objptr);
      if (D.19248 == 0) goto <D.19249>; else goto <D.19250>;
      <D.19249>:
      gc_debug_level.47 = gc_debug_level;
      D.19085 = gc_debug_level.47 >= 0;
      D.19086 = (long int) D.19085;
      D.19087 = __builtin_expect (D.19086, 0);
      if (D.19087 != 0) goto <D.19251>; else goto <D.19252>;
      <D.19251>:
      gc_debug_file.46 = gc_debug_file;
      D.19237 = *_objptr;
      _objptr.54 = (long int) _objptr;
      start.49 = (long int) start;
      D.19254 = _objptr.54 - start.49;
      D.19093 = MEM[(struct MonoObject *)start].vtable;
      D.19094 = D.19093->klass;
      D.19095 = D.19094->name_space;
      D.19093 = MEM[(struct MonoObject *)start].vtable;
      D.19094 = D.19093->klass;
      D.19096 = D.19094->name;
      fprintf (gc_debug_file.46, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.19237, D.19254, start, D.19095, D.19096);
      gc_debug_file.46 = gc_debug_file;
      fflush (gc_debug_file.46);
      <D.19252>:
      <D.19250>:
      <D.19245>:
      <D.19242>:
      <D.19239>:
      <D.19236>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.17997>:
      if (_bmap != 0) goto <D.17996>; else goto <D.17998>;
      <D.17998>:
    }
    goto <D.17954>;
    <D.17999>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

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

        myobj = start;
        D.19260 = myobj->vtable;
        D.19261 = D.19260->klass;
        D.19262 = D.19261->name_space;
        D.19260 = myobj->vtable;
        D.19261 = D.19260->klass;
        D.19263 = D.19261->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19262, D.19263);
      }
      <D.19259>:
      goto <D.18010>;
      <D.18009>:
      {
        gsize _bmap;

        bitmap_data.55 = bitmap_data;
        bitmap_data = bitmap_data.55 + 8;
        _bmap = *bitmap_data.55;
        _objptr = start_run;
        goto <D.18007>;
        <D.18006>:
        D.19265 = _bmap & 1;
        if (D.19265 != 0) goto <D.19266>; else goto <D.19267>;
        <D.19266>:
        D.19268 = *_objptr;
        if (D.19268 != 0B) goto <D.19269>; else goto <D.19270>;
        <D.19269>:
        D.19268 = *_objptr;
        D.19271 = sgen_ptr_in_nursery (D.19268);
        if (D.19271 == 0) goto <D.19272>; else goto <D.19273>;
        <D.19272>:
        D.19268 = *_objptr;
        D.19274 = is_major_or_los_object_marked (D.19268);
        if (D.19274 == 0) goto <D.19275>; else goto <D.19276>;
        <D.19275>:
        D.19277 = sgen_get_remset ();
        D.19278 = D.19277->find_address_with_cards;
        D.19279 = D.19278 (start, cards, _objptr);
        if (D.19279 == 0) goto <D.19280>; else goto <D.19281>;
        <D.19280>:
        gc_debug_level.47 = gc_debug_level;
        D.19085 = gc_debug_level.47 >= 0;
        D.19086 = (long int) D.19085;
        D.19087 = __builtin_expect (D.19086, 0);
        if (D.19087 != 0) goto <D.19282>; else goto <D.19283>;
        <D.19282>:
        gc_debug_file.46 = gc_debug_file;
        D.19268 = *_objptr;
        _objptr.56 = (long int) _objptr;
        start.49 = (long int) start;
        D.19285 = _objptr.56 - start.49;
        D.19093 = MEM[(struct MonoObject *)start].vtable;
        D.19094 = D.19093->klass;
        D.19095 = D.19094->name_space;
        D.19093 = MEM[(struct MonoObject *)start].vtable;
        D.19094 = D.19093->klass;
        D.19096 = D.19094->name;
        fprintf (gc_debug_file.46, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.19268, D.19285, start, D.19095, D.19096);
        gc_debug_file.46 = gc_debug_file;
        fflush (gc_debug_file.46);
        <D.19283>:
        <D.19281>:
        <D.19276>:
        <D.19273>:
        <D.19270>:
        <D.19267>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18007>:
        if (_bmap != 0) goto <D.18006>; else goto <D.18008>;
        <D.18008>:
        start_run = start_run + 512;
      }
      <D.18010>:
      bwords.57 = bwords;
      bwords = bwords.57 + -1;
      if (bwords.57 > 0) goto <D.18009>; else goto <D.18011>;
      <D.18011>:
    }
    goto <D.17954>;
    <D.18012>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19287 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19287);
      mbitmap_data.58 = mbitmap_data;
      mbitmap_data = mbitmap_data.58 + 8;
      D.19289 = *mbitmap_data.58;
      D.19290 = (unsigned int) D.19289;
      D.19291 = D.19290 + 4294967295;
      mbwords = (int) D.19291;
      D.19292 = vt->klass;
      el_size = mono_array_element_size (D.19292);
      e_start = start + 32;
      D.19159 = MEM[(struct MonoArray *)start].max_length;
      el_size.59 = (unsigned int) el_size;
      D.19294 = D.19159 * el_size.59;
      D.19295 = (sizetype) D.19294;
      e_end = e_start + D.19295;
      if (0 != 0) goto <D.19296>; else goto <D.19297>;
      <D.19296>:
      D.19287 = vt->desc;
      D.19292 = vt->klass;
      D.19298 = D.19292->name_space;
      D.19292 = vt->klass;
      D.19299 = D.19292->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19287, D.19298, D.19299);
      <D.19297>:
      goto <D.18030>;
      <D.18029>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.60 = bitmap_data;
          bitmap_data = bitmap_data.60 + 8;
          _bmap = *bitmap_data.60;
          start_run = _objptr;
          goto <D.18024>;
          <D.18023>:
          D.19301 = _bmap & 1;
          if (D.19301 != 0) goto <D.19302>; else goto <D.19303>;
          <D.19302>:
          D.19304 = *_objptr;
          if (D.19304 != 0B) goto <D.19305>; else goto <D.19306>;
          <D.19305>:
          D.19304 = *_objptr;
          D.19307 = sgen_ptr_in_nursery (D.19304);
          if (D.19307 == 0) goto <D.19308>; else goto <D.19309>;
          <D.19308>:
          D.19304 = *_objptr;
          D.19310 = is_major_or_los_object_marked (D.19304);
          if (D.19310 == 0) goto <D.19311>; else goto <D.19312>;
          <D.19311>:
          D.19313 = sgen_get_remset ();
          D.19314 = D.19313->find_address_with_cards;
          D.19315 = D.19314 (start, cards, _objptr);
          if (D.19315 == 0) goto <D.19316>; else goto <D.19317>;
          <D.19316>:
          gc_debug_level.47 = gc_debug_level;
          D.19085 = gc_debug_level.47 >= 0;
          D.19086 = (long int) D.19085;
          D.19087 = __builtin_expect (D.19086, 0);
          if (D.19087 != 0) goto <D.19318>; else goto <D.19319>;
          <D.19318>:
          gc_debug_file.46 = gc_debug_file;
          D.19304 = *_objptr;
          _objptr.61 = (long int) _objptr;
          start.49 = (long int) start;
          D.19321 = _objptr.61 - start.49;
          D.19093 = MEM[(struct MonoObject *)start].vtable;
          D.19094 = D.19093->klass;
          D.19095 = D.19094->name_space;
          D.19093 = MEM[(struct MonoObject *)start].vtable;
          D.19094 = D.19093->klass;
          D.19096 = D.19094->name;
          fprintf (gc_debug_file.46, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.19304, D.19321, start, D.19095, D.19096);
          gc_debug_file.46 = gc_debug_file;
          fflush (gc_debug_file.46);
          <D.19319>:
          <D.19317>:
          <D.19312>:
          <D.19309>:
          <D.19306>:
          <D.19303>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18024>:
          if (_bmap != 0) goto <D.18023>; else goto <D.18025>;
          <D.18025>:
          _objptr = start_run + 512;
        }
        <D.18027>:
        bwords.62 = bwords;
        bwords = bwords.62 + 4294967295;
        if (bwords.62 != 0) goto <D.18026>; else goto <D.18028>;
        <D.18028>:
        D.19323 = (sizetype) el_size;
        e_start = e_start + D.19323;
      }
      <D.18030>:
      if (e_start < e_end) goto <D.18029>; else goto <D.18031>;
      <D.18031>:
    }
    goto <D.17954>;
    <D.18032>:
    goto <D.17954>;
    <D.18033>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17954>:
  }
}


is_major_or_los_object_marked (char * obj)
{
  unsigned int D.19326;
  gboolean D.19329;
  struct SgenMajorCollector * D.19330;
  gboolean (*<T2dda>) (char *) D.19331;

  D.19326 = sgen_safe_object_get_size (obj);
  if (D.19326 > 8000) goto <D.19327>; else goto <D.19328>;
  <D.19327>:
  D.19329 = sgen_los_object_is_pinned (obj);
  return D.19329;
  <D.19328>:
  D.19330 = sgen_get_major_collector ();
  D.19331 = D.19330->is_object_live;
  D.19329 = D.19331 (obj);
  return D.19329;
}


sgen_check_major_refs ()
{
  void (*<T2e34>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.19333;

  D.19333 = major_collector.iterate_objects;
  D.19333 (1, 1, check_major_refs_callback, 0B);
  sgen_los_iterate_objects (check_major_refs_callback, 0B);
}


check_major_refs_callback (char * start, size_t size, void * dummy)
{
  long unsigned int D.19334;
  long unsigned int D.19335;
  long unsigned int D.19336;
  long unsigned int D.19337;
  long unsigned int D.19340;
  long unsigned int D.19341;
  long unsigned int D.19342;
  long unsigned int D.19343;
  long unsigned int D.19344;
  long unsigned int D.19345;
  void * D.19346;
  long unsigned int D.19349;
  long unsigned int D.19350;
  long int _objptr.63;
  long int start.64;
  long int D.19355;
  unsigned int D.19356;
  unsigned int D.19361;
  long unsigned int D.19362;
  long unsigned int D.19363;
  int D.19364;
  void * D.19365;
  long unsigned int D.19368;
  long unsigned int D.19369;
  long int _objptr.65;
  long int D.19373;
  unsigned int D.19374;
  long unsigned int D.19375;
  long unsigned int D.19376;
  int D.19377;
  unsigned int D.19382;
  long unsigned int D.19383;
  long unsigned int D.19386;
  int D.19387;
  int D.19388;
  unsigned int D.19391;
  unsigned int el_size.66;
  unsigned int D.19393;
  sizetype D.19394;
  void * D.19395;
  long unsigned int D.19398;
  long unsigned int D.19399;
  long int p.67;
  long int D.19403;
  unsigned int D.19404;
  int D.19408;
  int D.19409;
  long unsigned int D.19410;
  long unsigned int D.19411;
  long unsigned int D.19412;
  long unsigned int D.19413;
  void * * D.19414;
  void * D.19415;
  long unsigned int D.19418;
  long unsigned int D.19419;
  sizetype D.19422;
  char * D.19423;
  long int D.19424;
  long int D.19425;
  unsigned int D.19426;
  sizetype D.19427;
  long unsigned int D.19431;
  void * D.19434;
  long unsigned int D.19437;
  long unsigned int D.19438;
  long int p.68;
  long int D.19442;
  unsigned int D.19443;
  long unsigned int D.19444;
  void * D.19447;
  long unsigned int D.19450;
  long unsigned int D.19451;
  long int _objptr.69;
  long int D.19455;
  unsigned int D.19456;
  long unsigned int D.19457;
  unsigned int D.19458;
  unsigned int D.19459;
  struct MonoVTable * D.19462;
  struct MonoClass * D.19463;
  const char * D.19464;
  const char * D.19465;
  gsize * bitmap_data.70;
  long unsigned int D.19467;
  void * D.19470;
  long unsigned int D.19473;
  long unsigned int D.19474;
  long int _objptr.71;
  long int D.19478;
  unsigned int D.19479;
  int bwords.72;
  long unsigned int D.19481;
  gsize * mbitmap_data.73;
  long unsigned int D.19483;
  unsigned int D.19484;
  unsigned int D.19485;
  struct MonoClass * D.19486;
  unsigned int el_size.74;
  unsigned int D.19488;
  sizetype D.19489;
  const char * D.19492;
  const char * D.19493;
  gsize * bitmap_data.75;
  long unsigned int D.19495;
  void * D.19498;
  long unsigned int D.19501;
  long unsigned int D.19502;
  long int _objptr.76;
  long int D.19506;
  unsigned int D.19507;
  unsigned int bwords.77;
  sizetype D.19509;

  {
    struct GCVTable * vt;
    mword desc;

    D.19334 = MEM[(mword *)start];
    D.19335 = D.19334 & 18446744073709551612;
    vt = (struct GCVTable *) D.19335;
    desc = vt->desc;
    D.19336 = desc & 7;
    switch (D.19336) <default: <D.18139>, case 1: <D.18044>, case 2: <D.18053>, case 3: <D.18103>, case 4: <D.18063>, case 5: <D.18096>, case 6: <D.18117>, case 7: <D.18138>>
    <D.18044>:
    D.19337 = desc & 4294901760;
    if (D.19337 != 0) goto <D.19338>; else goto <D.19339>;
    <D.19338>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19340 = desc >> 16;
      D.19341 = D.19340 & 255;
      D.19342 = D.19341 * 8;
      _objptr = _objptr + D.19342;
      D.19343 = desc >> 24;
      D.19344 = D.19343 & 255;
      D.19345 = D.19344 * 8;
      _objptr_end = _objptr + D.19345;
      D.19346 = *_objptr;
      if (D.19346 != 0B) goto <D.19347>; else goto <D.19348>;
      <D.19347>:
      D.19346 = *_objptr;
      D.19349 = MEM[(mword *)D.19346];
      D.19350 = D.19349 & 18446744073709551612;
      if (D.19350 == 0) goto <D.19351>; else goto <D.19352>;
      <D.19351>:
      _objptr.63 = (long int) _objptr;
      start.64 = (long int) start;
      D.19355 = _objptr.63 - start.64;
      D.19356 = sgen_safe_object_get_size (start);
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.19355, D.19356);
      <D.18047>:
      goto <D.18047>;
      <D.19352>:
      <D.19348>:
      _objptr = _objptr + 8;
      goto <D.18050>;
      <D.18049>:
      D.19346 = *_objptr;
      if (D.19346 != 0B) goto <D.19357>; else goto <D.19358>;
      <D.19357>:
      D.19346 = *_objptr;
      D.19349 = MEM[(mword *)D.19346];
      D.19350 = D.19349 & 18446744073709551612;
      if (D.19350 == 0) goto <D.19359>; else goto <D.19360>;
      <D.19359>:
      _objptr.63 = (long int) _objptr;
      start.64 = (long int) start;
      D.19355 = _objptr.63 - start.64;
      D.19361 = sgen_safe_object_get_size (start);
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.19355, D.19361);
      <D.18048>:
      goto <D.18048>;
      <D.19360>:
      <D.19358>:
      _objptr = _objptr + 8;
      <D.18050>:
      if (_objptr < _objptr_end) goto <D.18049>; else goto <D.18051>;
      <D.18051>:
    }
    <D.19339>:
    goto <D.18052>;
    <D.18053>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.19362 = (long unsigned int) _index;
        D.19363 = D.19362 * 8;
        _objptr = _objptr + D.19363;
        D.19364 = _index + 1;
        _bmap = _bmap >> D.19364;
        D.19365 = *_objptr;
        if (D.19365 != 0B) goto <D.19366>; else goto <D.19367>;
        <D.19366>:
        D.19365 = *_objptr;
        D.19368 = MEM[(mword *)D.19365];
        D.19369 = D.19368 & 18446744073709551612;
        if (D.19369 == 0) goto <D.19370>; else goto <D.19371>;
        <D.19370>:
        _objptr.65 = (long int) _objptr;
        start.64 = (long int) start;
        D.19373 = _objptr.65 - start.64;
        D.19374 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.19373, D.19374);
        <D.18057>:
        goto <D.18057>;
        <D.19371>:
        <D.19367>:
        _objptr = _objptr + 8;
      }
      goto <D.18061>;
      <D.18060>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.19375 = (long unsigned int) _index;
        D.19376 = D.19375 * 8;
        _objptr = _objptr + D.19376;
        D.19377 = _index + 1;
        _bmap = _bmap >> D.19377;
        D.19365 = *_objptr;
        if (D.19365 != 0B) goto <D.19378>; else goto <D.19379>;
        <D.19378>:
        D.19365 = *_objptr;
        D.19368 = MEM[(mword *)D.19365];
        D.19369 = D.19368 & 18446744073709551612;
        if (D.19369 == 0) goto <D.19380>; else goto <D.19381>;
        <D.19380>:
        _objptr.65 = (long int) _objptr;
        start.64 = (long int) start;
        D.19373 = _objptr.65 - start.64;
        D.19382 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.19373, D.19382);
        <D.18059>:
        goto <D.18059>;
        <D.19381>:
        <D.19379>:
        _objptr = _objptr + 8;
      }
      <D.18061>:
      if (_bmap != 0) goto <D.18060>; else goto <D.18062>;
      <D.18062>:
    }
    goto <D.18052>;
    <D.18063>:
    D.19383 = desc & 4294950912;
    if (D.19383 != 0) goto <D.19384>; else goto <D.19385>;
    <D.19384>:
    {
      int el_size;
      int etype;

      D.19386 = desc >> 3;
      D.19387 = (int) D.19386;
      el_size = D.19387 & 1023;
      D.19388 = (int) desc;
      etype = D.19388 & 49152;
      if (etype == 16384) goto <D.19389>; else goto <D.19390>;
      <D.19389>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.19391 = MEM[(struct MonoArray *)start].max_length;
        el_size.66 = (unsigned int) el_size;
        D.19393 = D.19391 * el_size.66;
        D.19394 = (sizetype) D.19393;
        end_refs = p + D.19394;
        goto <D.18070>;
        <D.18069>:
        D.19395 = *p;
        if (D.19395 != 0B) goto <D.19396>; else goto <D.19397>;
        <D.19396>:
        D.19395 = *p;
        D.19398 = MEM[(mword *)D.19395];
        D.19399 = D.19398 & 18446744073709551612;
        if (D.19399 == 0) goto <D.19400>; else goto <D.19401>;
        <D.19400>:
        p.67 = (long int) p;
        start.64 = (long int) start;
        D.19403 = p.67 - start.64;
        D.19404 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.19403, D.19404);
        <D.18068>:
        goto <D.18068>;
        <D.19401>:
        <D.19397>:
        p = p + 8;
        <D.18070>:
        if (p < end_refs) goto <D.18069>; else goto <D.18071>;
        <D.18071>:
      }
      goto <D.19405>;
      <D.19390>:
      if (etype == 32768) goto <D.19406>; else goto <D.19407>;
      <D.19406>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19340 = desc >> 16;
        D.19408 = (int) D.19340;
        offset = D.19408 & 255;
        D.19343 = desc >> 24;
        D.19409 = (int) D.19343;
        num_refs = D.19409 & 255;
        e_start = start + 32;
        D.19391 = MEM[(struct MonoArray *)start].max_length;
        el_size.66 = (unsigned int) el_size;
        D.19393 = D.19391 * el_size.66;
        D.19394 = (sizetype) D.19393;
        e_end = e_start + D.19394;
        goto <D.18083>;
        <D.18082>:
        {
          void * * p;
          int i;

          p = e_start;
          D.19410 = (long unsigned int) offset;
          D.19411 = D.19410 * 8;
          p = p + D.19411;
          i = 0;
          goto <D.18080>;
          <D.18079>:
          D.19412 = (long unsigned int) i;
          D.19413 = D.19412 * 8;
          D.19414 = p + D.19413;
          D.19415 = *D.19414;
          if (D.19415 != 0B) goto <D.19416>; else goto <D.19417>;
          <D.19416>:
          D.19412 = (long unsigned int) i;
          D.19413 = D.19412 * 8;
          D.19414 = p + D.19413;
          D.19415 = *D.19414;
          D.19418 = MEM[(mword *)D.19415];
          D.19419 = D.19418 & 18446744073709551612;
          if (D.19419 == 0) goto <D.19420>; else goto <D.19421>;
          <D.19420>:
          D.19422 = (sizetype) i;
          D.19423 = p + D.19422;
          D.19424 = (long int) D.19423;
          start.64 = (long int) start;
          D.19425 = D.19424 - start.64;
          D.19426 = sgen_safe_object_get_size (start);
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.19425, D.19426);
          <D.18078>:
          goto <D.18078>;
          <D.19421>:
          <D.19417>:
          i = i + 1;
          <D.18080>:
          if (i < num_refs) goto <D.18079>; else goto <D.18081>;
          <D.18081>:
          D.19427 = (sizetype) el_size;
          e_start = e_start + D.19427;
        }
        <D.18083>:
        if (e_start < e_end) goto <D.18082>; else goto <D.18084>;
        <D.18084>:
      }
      goto <D.19428>;
      <D.19407>:
      if (etype == 49152) goto <D.19429>; else goto <D.19430>;
      <D.19429>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.19391 = MEM[(struct MonoArray *)start].max_length;
        el_size.66 = (unsigned int) el_size;
        D.19393 = D.19391 * el_size.66;
        D.19394 = (sizetype) D.19393;
        e_end = e_start + D.19394;
        goto <D.18094>;
        <D.18093>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.18091>;
          <D.18090>:
          D.19431 = _bmap & 1;
          if (D.19431 != 0) goto <D.19432>; else goto <D.19433>;
          <D.19432>:
          D.19434 = *p;
          if (D.19434 != 0B) goto <D.19435>; else goto <D.19436>;
          <D.19435>:
          D.19434 = *p;
          D.19437 = MEM[(mword *)D.19434];
          D.19438 = D.19437 & 18446744073709551612;
          if (D.19438 == 0) goto <D.19439>; else goto <D.19440>;
          <D.19439>:
          p.68 = (long int) p;
          start.64 = (long int) start;
          D.19442 = p.68 - start.64;
          D.19443 = sgen_safe_object_get_size (start);
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.19442, D.19443);
          <D.18089>:
          goto <D.18089>;
          <D.19440>:
          <D.19436>:
          <D.19433>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.18091>:
          if (_bmap != 0) goto <D.18090>; else goto <D.18092>;
          <D.18092>:
          D.19427 = (sizetype) el_size;
          e_start = e_start + D.19427;
        }
        <D.18094>:
        if (e_start < e_end) goto <D.18093>; else goto <D.18095>;
        <D.18095>:
      }
      <D.19430>:
      <D.19428>:
      <D.19405>:
    }
    <D.19385>:
    goto <D.18052>;
    <D.18096>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.18101>;
      <D.18100>:
      D.19444 = _bmap & 1;
      if (D.19444 != 0) goto <D.19445>; else goto <D.19446>;
      <D.19445>:
      D.19447 = *_objptr;
      if (D.19447 != 0B) goto <D.19448>; else goto <D.19449>;
      <D.19448>:
      D.19447 = *_objptr;
      D.19450 = MEM[(mword *)D.19447];
      D.19451 = D.19450 & 18446744073709551612;
      if (D.19451 == 0) goto <D.19452>; else goto <D.19453>;
      <D.19452>:
      _objptr.69 = (long int) _objptr;
      start.64 = (long int) start;
      D.19455 = _objptr.69 - start.64;
      D.19456 = sgen_safe_object_get_size (start);
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.19455, D.19456);
      <D.18099>:
      goto <D.18099>;
      <D.19453>:
      <D.19449>:
      <D.19446>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18101>:
      if (_bmap != 0) goto <D.18100>; else goto <D.18102>;
      <D.18102>:
    }
    goto <D.18052>;
    <D.18103>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19457 = *bitmap_data;
      D.19458 = (unsigned int) D.19457;
      D.19459 = D.19458 + 4294967295;
      bwords = (int) D.19459;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.19460>; else goto <D.19461>;
      <D.19460>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19462 = myobj->vtable;
        D.19463 = D.19462->klass;
        D.19464 = D.19463->name_space;
        D.19462 = myobj->vtable;
        D.19463 = D.19462->klass;
        D.19465 = D.19463->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19464, D.19465);
      }
      <D.19461>:
      goto <D.18115>;
      <D.18114>:
      {
        gsize _bmap;

        bitmap_data.70 = bitmap_data;
        bitmap_data = bitmap_data.70 + 8;
        _bmap = *bitmap_data.70;
        _objptr = start_run;
        goto <D.18112>;
        <D.18111>:
        D.19467 = _bmap & 1;
        if (D.19467 != 0) goto <D.19468>; else goto <D.19469>;
        <D.19468>:
        D.19470 = *_objptr;
        if (D.19470 != 0B) goto <D.19471>; else goto <D.19472>;
        <D.19471>:
        D.19470 = *_objptr;
        D.19473 = MEM[(mword *)D.19470];
        D.19474 = D.19473 & 18446744073709551612;
        if (D.19474 == 0) goto <D.19475>; else goto <D.19476>;
        <D.19475>:
        _objptr.71 = (long int) _objptr;
        start.64 = (long int) start;
        D.19478 = _objptr.71 - start.64;
        D.19479 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.19478, D.19479);
        <D.18110>:
        goto <D.18110>;
        <D.19476>:
        <D.19472>:
        <D.19469>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18112>:
        if (_bmap != 0) goto <D.18111>; else goto <D.18113>;
        <D.18113>:
        start_run = start_run + 512;
      }
      <D.18115>:
      bwords.72 = bwords;
      bwords = bwords.72 + -1;
      if (bwords.72 > 0) goto <D.18114>; else goto <D.18116>;
      <D.18116>:
    }
    goto <D.18052>;
    <D.18117>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19481 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19481);
      mbitmap_data.73 = mbitmap_data;
      mbitmap_data = mbitmap_data.73 + 8;
      D.19483 = *mbitmap_data.73;
      D.19484 = (unsigned int) D.19483;
      D.19485 = D.19484 + 4294967295;
      mbwords = (int) D.19485;
      D.19486 = vt->klass;
      el_size = mono_array_element_size (D.19486);
      e_start = start + 32;
      D.19391 = MEM[(struct MonoArray *)start].max_length;
      el_size.74 = (unsigned int) el_size;
      D.19488 = D.19391 * el_size.74;
      D.19489 = (sizetype) D.19488;
      e_end = e_start + D.19489;
      if (0 != 0) goto <D.19490>; else goto <D.19491>;
      <D.19490>:
      D.19481 = vt->desc;
      D.19486 = vt->klass;
      D.19492 = D.19486->name_space;
      D.19486 = vt->klass;
      D.19493 = D.19486->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19481, D.19492, D.19493);
      <D.19491>:
      goto <D.18136>;
      <D.18135>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.75 = bitmap_data;
          bitmap_data = bitmap_data.75 + 8;
          _bmap = *bitmap_data.75;
          start_run = _objptr;
          goto <D.18130>;
          <D.18129>:
          D.19495 = _bmap & 1;
          if (D.19495 != 0) goto <D.19496>; else goto <D.19497>;
          <D.19496>:
          D.19498 = *_objptr;
          if (D.19498 != 0B) goto <D.19499>; else goto <D.19500>;
          <D.19499>:
          D.19498 = *_objptr;
          D.19501 = MEM[(mword *)D.19498];
          D.19502 = D.19501 & 18446744073709551612;
          if (D.19502 == 0) goto <D.19503>; else goto <D.19504>;
          <D.19503>:
          _objptr.76 = (long int) _objptr;
          start.64 = (long int) start;
          D.19506 = _objptr.76 - start.64;
          D.19507 = sgen_safe_object_get_size (start);
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.19506, D.19507);
          <D.18128>:
          goto <D.18128>;
          <D.19504>:
          <D.19500>:
          <D.19497>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18130>:
          if (_bmap != 0) goto <D.18129>; else goto <D.18131>;
          <D.18131>:
          _objptr = start_run + 512;
        }
        <D.18133>:
        bwords.77 = bwords;
        bwords = bwords.77 + 4294967295;
        if (bwords.77 != 0) goto <D.18132>; else goto <D.18134>;
        <D.18134>:
        D.19509 = (sizetype) el_size;
        e_start = e_start + D.19509;
      }
      <D.18136>:
      if (e_start < e_end) goto <D.18135>; else goto <D.18137>;
      <D.18137>:
    }
    goto <D.18052>;
    <D.18138>:
    goto <D.18052>;
    <D.18139>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.18052>:
  }
}


check_object (char * start)
{
  long unsigned int D.19513;
  long unsigned int D.19514;
  long unsigned int D.19515;
  long unsigned int D.19516;
  long unsigned int D.19519;
  long unsigned int D.19520;
  long unsigned int D.19521;
  long unsigned int D.19522;
  long unsigned int D.19523;
  long unsigned int D.19524;
  void * D.19525;
  const char * D.19528;
  _Bool D.19529;
  long int D.19530;
  long int D.19531;
  const char * D.19536;
  _Bool D.19537;
  long int D.19538;
  long int D.19539;
  long unsigned int D.19542;
  long unsigned int D.19543;
  int D.19544;
  void * D.19545;
  const char * D.19548;
  _Bool D.19549;
  long int D.19550;
  long int D.19551;
  long unsigned int D.19554;
  long unsigned int D.19555;
  int D.19556;
  const char * D.19559;
  _Bool D.19560;
  long int D.19561;
  long int D.19562;
  long unsigned int D.19565;
  long unsigned int D.19568;
  int D.19569;
  int D.19570;
  unsigned int D.19573;
  unsigned int el_size.78;
  unsigned int D.19575;
  sizetype D.19576;
  void * D.19577;
  const char * D.19580;
  _Bool D.19581;
  long int D.19582;
  long int D.19583;
  int D.19589;
  int D.19590;
  long unsigned int D.19591;
  long unsigned int D.19592;
  long unsigned int D.19593;
  long unsigned int D.19594;
  void * * D.19595;
  void * D.19596;
  const char * D.19599;
  _Bool D.19600;
  long int D.19601;
  long int D.19602;
  sizetype D.19605;
  long unsigned int D.19609;
  void * D.19612;
  const char * D.19615;
  _Bool D.19616;
  long int D.19617;
  long int D.19618;
  long unsigned int D.19621;
  void * D.19624;
  const char * D.19627;
  _Bool D.19628;
  long int D.19629;
  long int D.19630;
  long unsigned int D.19633;
  unsigned int D.19634;
  unsigned int D.19635;
  struct MonoVTable * D.19638;
  struct MonoClass * D.19639;
  const char * D.19640;
  const char * D.19641;
  gsize * bitmap_data.79;
  long unsigned int D.19643;
  void * D.19646;
  const char * D.19649;
  _Bool D.19650;
  long int D.19651;
  long int D.19652;
  int bwords.80;
  long unsigned int D.19656;
  gsize * mbitmap_data.81;
  long unsigned int D.19658;
  unsigned int D.19659;
  unsigned int D.19660;
  struct MonoClass * D.19661;
  unsigned int el_size.82;
  unsigned int D.19663;
  sizetype D.19664;
  const char * D.19667;
  const char * D.19668;
  gsize * bitmap_data.83;
  long unsigned int D.19670;
  void * D.19673;
  const char * D.19676;
  _Bool D.19677;
  long int D.19678;
  long int D.19679;
  unsigned int bwords.84;
  sizetype D.19683;

  if (start == 0B) goto <D.19511>; else goto <D.19512>;
  <D.19511>:
  return;
  <D.19512>:
  {
    struct GCVTable * vt;
    mword desc;

    D.19513 = MEM[(mword *)start];
    D.19514 = D.19513 & 18446744073709551612;
    vt = (struct GCVTable *) D.19514;
    desc = vt->desc;
    D.19515 = desc & 7;
    switch (D.19515) <default: <D.18233>, case 1: <D.18148>, case 2: <D.18155>, case 3: <D.18199>, case 4: <D.18163>, case 5: <D.18193>, case 6: <D.18212>, case 7: <D.18232>>
    <D.18148>:
    D.19516 = desc & 4294901760;
    if (D.19516 != 0) goto <D.19517>; else goto <D.19518>;
    <D.19517>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19519 = desc >> 16;
      D.19520 = D.19519 & 255;
      D.19521 = D.19520 * 8;
      _objptr = _objptr + D.19521;
      D.19522 = desc >> 24;
      D.19523 = D.19522 & 255;
      D.19524 = D.19523 * 8;
      _objptr_end = _objptr + D.19524;
      D.19525 = *_objptr;
      if (D.19525 != 0B) goto <D.19526>; else goto <D.19527>;
      <D.19526>:
      D.19525 = *_objptr;
      D.19528 = sgen_safe_name (D.19525);
      D.19529 = D.19528 == 0B;
      D.19530 = (long int) D.19529;
      D.19531 = __builtin_expect (D.19530, 0);
      if (D.19531 != 0) goto <D.19532>; else goto <D.19533>;
      <D.19532>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_safe_name (*(_objptr)) != NULL");
      <D.19533>:
      <D.19527>:
      _objptr = _objptr + 8;
      goto <D.18152>;
      <D.18151>:
      D.19525 = *_objptr;
      if (D.19525 != 0B) goto <D.19534>; else goto <D.19535>;
      <D.19534>:
      D.19525 = *_objptr;
      D.19536 = sgen_safe_name (D.19525);
      D.19537 = D.19536 == 0B;
      D.19538 = (long int) D.19537;
      D.19539 = __builtin_expect (D.19538, 0);
      if (D.19539 != 0) goto <D.19540>; else goto <D.19541>;
      <D.19540>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_safe_name (*(_objptr)) != NULL");
      <D.19541>:
      <D.19535>:
      _objptr = _objptr + 8;
      <D.18152>:
      if (_objptr < _objptr_end) goto <D.18151>; else goto <D.18153>;
      <D.18153>:
    }
    <D.19518>:
    goto <D.18154>;
    <D.18155>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.19542 = (long unsigned int) _index;
        D.19543 = D.19542 * 8;
        _objptr = _objptr + D.19543;
        D.19544 = _index + 1;
        _bmap = _bmap >> D.19544;
        D.19545 = *_objptr;
        if (D.19545 != 0B) goto <D.19546>; else goto <D.19547>;
        <D.19546>:
        D.19545 = *_objptr;
        D.19548 = sgen_safe_name (D.19545);
        D.19549 = D.19548 == 0B;
        D.19550 = (long int) D.19549;
        D.19551 = __builtin_expect (D.19550, 0);
        if (D.19551 != 0) goto <D.19552>; else goto <D.19553>;
        <D.19552>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_safe_name (*(_objptr)) != NULL");
        <D.19553>:
        <D.19547>:
        _objptr = _objptr + 8;
      }
      goto <D.18161>;
      <D.18160>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.19554 = (long unsigned int) _index;
        D.19555 = D.19554 * 8;
        _objptr = _objptr + D.19555;
        D.19556 = _index + 1;
        _bmap = _bmap >> D.19556;
        D.19545 = *_objptr;
        if (D.19545 != 0B) goto <D.19557>; else goto <D.19558>;
        <D.19557>:
        D.19545 = *_objptr;
        D.19559 = sgen_safe_name (D.19545);
        D.19560 = D.19559 == 0B;
        D.19561 = (long int) D.19560;
        D.19562 = __builtin_expect (D.19561, 0);
        if (D.19562 != 0) goto <D.19563>; else goto <D.19564>;
        <D.19563>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_safe_name (*(_objptr)) != NULL");
        <D.19564>:
        <D.19558>:
        _objptr = _objptr + 8;
      }
      <D.18161>:
      if (_bmap != 0) goto <D.18160>; else goto <D.18162>;
      <D.18162>:
    }
    goto <D.18154>;
    <D.18163>:
    D.19565 = desc & 4294950912;
    if (D.19565 != 0) goto <D.19566>; else goto <D.19567>;
    <D.19566>:
    {
      int el_size;
      int etype;

      D.19568 = desc >> 3;
      D.19569 = (int) D.19568;
      el_size = D.19569 & 1023;
      D.19570 = (int) desc;
      etype = D.19570 & 49152;
      if (etype == 16384) goto <D.19571>; else goto <D.19572>;
      <D.19571>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.19573 = MEM[(struct MonoArray *)start].max_length;
        el_size.78 = (unsigned int) el_size;
        D.19575 = D.19573 * el_size.78;
        D.19576 = (sizetype) D.19575;
        end_refs = p + D.19576;
        goto <D.18169>;
        <D.18168>:
        D.19577 = *p;
        if (D.19577 != 0B) goto <D.19578>; else goto <D.19579>;
        <D.19578>:
        D.19577 = *p;
        D.19580 = sgen_safe_name (D.19577);
        D.19581 = D.19580 == 0B;
        D.19582 = (long int) D.19581;
        D.19583 = __builtin_expect (D.19582, 0);
        if (D.19583 != 0) goto <D.19584>; else goto <D.19585>;
        <D.19584>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p)) != NULL");
        <D.19585>:
        <D.19579>:
        p = p + 8;
        <D.18169>:
        if (p < end_refs) goto <D.18168>; else goto <D.18170>;
        <D.18170>:
      }
      goto <D.19586>;
      <D.19572>:
      if (etype == 32768) goto <D.19587>; else goto <D.19588>;
      <D.19587>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19519 = desc >> 16;
        D.19589 = (int) D.19519;
        offset = D.19589 & 255;
        D.19522 = desc >> 24;
        D.19590 = (int) D.19522;
        num_refs = D.19590 & 255;
        e_start = start + 32;
        D.19573 = MEM[(struct MonoArray *)start].max_length;
        el_size.78 = (unsigned int) el_size;
        D.19575 = D.19573 * el_size.78;
        D.19576 = (sizetype) D.19575;
        e_end = e_start + D.19576;
        goto <D.18181>;
        <D.18180>:
        {
          void * * p;
          int i;

          p = e_start;
          D.19591 = (long unsigned int) offset;
          D.19592 = D.19591 * 8;
          p = p + D.19592;
          i = 0;
          goto <D.18178>;
          <D.18177>:
          D.19593 = (long unsigned int) i;
          D.19594 = D.19593 * 8;
          D.19595 = p + D.19594;
          D.19596 = *D.19595;
          if (D.19596 != 0B) goto <D.19597>; else goto <D.19598>;
          <D.19597>:
          D.19593 = (long unsigned int) i;
          D.19594 = D.19593 * 8;
          D.19595 = p + D.19594;
          D.19596 = *D.19595;
          D.19599 = sgen_safe_name (D.19596);
          D.19600 = D.19599 == 0B;
          D.19601 = (long int) D.19600;
          D.19602 = __builtin_expect (D.19601, 0);
          if (D.19602 != 0) goto <D.19603>; else goto <D.19604>;
          <D.19603>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p + i)) != NULL");
          <D.19604>:
          <D.19598>:
          i = i + 1;
          <D.18178>:
          if (i < num_refs) goto <D.18177>; else goto <D.18179>;
          <D.18179>:
          D.19605 = (sizetype) el_size;
          e_start = e_start + D.19605;
        }
        <D.18181>:
        if (e_start < e_end) goto <D.18180>; else goto <D.18182>;
        <D.18182>:
      }
      goto <D.19606>;
      <D.19588>:
      if (etype == 49152) goto <D.19607>; else goto <D.19608>;
      <D.19607>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.19573 = MEM[(struct MonoArray *)start].max_length;
        el_size.78 = (unsigned int) el_size;
        D.19575 = D.19573 * el_size.78;
        D.19576 = (sizetype) D.19575;
        e_end = e_start + D.19576;
        goto <D.18191>;
        <D.18190>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.18188>;
          <D.18187>:
          D.19609 = _bmap & 1;
          if (D.19609 != 0) goto <D.19610>; else goto <D.19611>;
          <D.19610>:
          D.19612 = *p;
          if (D.19612 != 0B) goto <D.19613>; else goto <D.19614>;
          <D.19613>:
          D.19612 = *p;
          D.19615 = sgen_safe_name (D.19612);
          D.19616 = D.19615 == 0B;
          D.19617 = (long int) D.19616;
          D.19618 = __builtin_expect (D.19617, 0);
          if (D.19618 != 0) goto <D.19619>; else goto <D.19620>;
          <D.19619>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p)) != NULL");
          <D.19620>:
          <D.19614>:
          <D.19611>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.18188>:
          if (_bmap != 0) goto <D.18187>; else goto <D.18189>;
          <D.18189>:
          D.19605 = (sizetype) el_size;
          e_start = e_start + D.19605;
        }
        <D.18191>:
        if (e_start < e_end) goto <D.18190>; else goto <D.18192>;
        <D.18192>:
      }
      <D.19608>:
      <D.19606>:
      <D.19586>:
    }
    <D.19567>:
    goto <D.18154>;
    <D.18193>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.18197>;
      <D.18196>:
      D.19621 = _bmap & 1;
      if (D.19621 != 0) goto <D.19622>; else goto <D.19623>;
      <D.19622>:
      D.19624 = *_objptr;
      if (D.19624 != 0B) goto <D.19625>; else goto <D.19626>;
      <D.19625>:
      D.19624 = *_objptr;
      D.19627 = sgen_safe_name (D.19624);
      D.19628 = D.19627 == 0B;
      D.19629 = (long int) D.19628;
      D.19630 = __builtin_expect (D.19629, 0);
      if (D.19630 != 0) goto <D.19631>; else goto <D.19632>;
      <D.19631>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "sgen_safe_name (*(_objptr)) != NULL");
      <D.19632>:
      <D.19626>:
      <D.19623>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18197>:
      if (_bmap != 0) goto <D.18196>; else goto <D.18198>;
      <D.18198>:
    }
    goto <D.18154>;
    <D.18199>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19633 = *bitmap_data;
      D.19634 = (unsigned int) D.19633;
      D.19635 = D.19634 + 4294967295;
      bwords = (int) D.19635;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.19636>; else goto <D.19637>;
      <D.19636>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19638 = myobj->vtable;
        D.19639 = D.19638->klass;
        D.19640 = D.19639->name_space;
        D.19638 = myobj->vtable;
        D.19639 = D.19638->klass;
        D.19641 = D.19639->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19640, D.19641);
      }
      <D.19637>:
      goto <D.18210>;
      <D.18209>:
      {
        gsize _bmap;

        bitmap_data.79 = bitmap_data;
        bitmap_data = bitmap_data.79 + 8;
        _bmap = *bitmap_data.79;
        _objptr = start_run;
        goto <D.18207>;
        <D.18206>:
        D.19643 = _bmap & 1;
        if (D.19643 != 0) goto <D.19644>; else goto <D.19645>;
        <D.19644>:
        D.19646 = *_objptr;
        if (D.19646 != 0B) goto <D.19647>; else goto <D.19648>;
        <D.19647>:
        D.19646 = *_objptr;
        D.19649 = sgen_safe_name (D.19646);
        D.19650 = D.19649 == 0B;
        D.19651 = (long int) D.19650;
        D.19652 = __builtin_expect (D.19651, 0);
        if (D.19652 != 0) goto <D.19653>; else goto <D.19654>;
        <D.19653>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "sgen_safe_name (*(_objptr)) != NULL");
        <D.19654>:
        <D.19648>:
        <D.19645>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18207>:
        if (_bmap != 0) goto <D.18206>; else goto <D.18208>;
        <D.18208>:
        start_run = start_run + 512;
      }
      <D.18210>:
      bwords.80 = bwords;
      bwords = bwords.80 + -1;
      if (bwords.80 > 0) goto <D.18209>; else goto <D.18211>;
      <D.18211>:
    }
    goto <D.18154>;
    <D.18212>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19656 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19656);
      mbitmap_data.81 = mbitmap_data;
      mbitmap_data = mbitmap_data.81 + 8;
      D.19658 = *mbitmap_data.81;
      D.19659 = (unsigned int) D.19658;
      D.19660 = D.19659 + 4294967295;
      mbwords = (int) D.19660;
      D.19661 = vt->klass;
      el_size = mono_array_element_size (D.19661);
      e_start = start + 32;
      D.19573 = MEM[(struct MonoArray *)start].max_length;
      el_size.82 = (unsigned int) el_size;
      D.19663 = D.19573 * el_size.82;
      D.19664 = (sizetype) D.19663;
      e_end = e_start + D.19664;
      if (0 != 0) goto <D.19665>; else goto <D.19666>;
      <D.19665>:
      D.19656 = vt->desc;
      D.19661 = vt->klass;
      D.19667 = D.19661->name_space;
      D.19661 = vt->klass;
      D.19668 = D.19661->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19656, D.19667, D.19668);
      <D.19666>:
      goto <D.18230>;
      <D.18229>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.83 = bitmap_data;
          bitmap_data = bitmap_data.83 + 8;
          _bmap = *bitmap_data.83;
          start_run = _objptr;
          goto <D.18224>;
          <D.18223>:
          D.19670 = _bmap & 1;
          if (D.19670 != 0) goto <D.19671>; else goto <D.19672>;
          <D.19671>:
          D.19673 = *_objptr;
          if (D.19673 != 0B) goto <D.19674>; else goto <D.19675>;
          <D.19674>:
          D.19673 = *_objptr;
          D.19676 = sgen_safe_name (D.19673);
          D.19677 = D.19676 == 0B;
          D.19678 = (long int) D.19677;
          D.19679 = __builtin_expect (D.19678, 0);
          if (D.19679 != 0) goto <D.19680>; else goto <D.19681>;
          <D.19680>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "sgen_safe_name (*(_objptr)) != NULL");
          <D.19681>:
          <D.19675>:
          <D.19672>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18224>:
          if (_bmap != 0) goto <D.18223>; else goto <D.18225>;
          <D.18225>:
          _objptr = start_run + 512;
        }
        <D.18227>:
        bwords.84 = bwords;
        bwords = bwords.84 + 4294967295;
        if (bwords.84 != 0) goto <D.18226>; else goto <D.18228>;
        <D.18228>:
        D.19683 = (sizetype) el_size;
        e_start = e_start + D.19683;
      }
      <D.18230>:
      if (e_start < e_end) goto <D.18229>; else goto <D.18231>;
      <D.18231>:
    }
    goto <D.18154>;
    <D.18232>:
    goto <D.18154>;
    <D.18233>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.18154>:
  }
}


sgen_check_whole_heap (gboolean allow_missing_pinned)
{
  struct GCMemSection * nursery_section.85;
  char * D.19687;
  char * D.19688;
  long unsigned int D.19689;
  void * D.19690;
  void (*<T2e34>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.19691;
  int broken_heap.86;
  _Bool D.19693;
  long int D.19694;
  long int D.19695;

  setup_valid_nursery_objects ();
  broken_heap = 0;
  nursery_section.85 = nursery_section;
  D.19687 = nursery_section.85->data;
  nursery_section.85 = nursery_section;
  D.19688 = nursery_section.85->end_data;
  D.19689 = (long unsigned int) allow_missing_pinned;
  D.19690 = (void *) D.19689;
  sgen_scan_area_with_callback (D.19687, D.19688, verify_object_pointers_callback, D.19690, 0);
  D.19691 = major_collector.iterate_objects;
  D.19689 = (long unsigned int) allow_missing_pinned;
  D.19690 = (void *) D.19689;
  D.19691 (1, 1, verify_object_pointers_callback, D.19690);
  D.19689 = (long unsigned int) allow_missing_pinned;
  D.19690 = (void *) D.19689;
  sgen_los_iterate_objects (verify_object_pointers_callback, D.19690);
  broken_heap.86 = broken_heap;
  D.19693 = broken_heap.86 != 0;
  D.19694 = (long int) D.19693;
  D.19695 = __builtin_expect (D.19694, 0);
  if (D.19695 != 0) goto <D.19696>; else goto <D.19697>;
  <D.19696>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 445, "!broken_heap");
  <D.19697>:
}


verify_object_pointers_callback (char * start, size_t size, void * data)
{
  long int data.87;
  long unsigned int D.19699;
  long unsigned int D.19700;
  long unsigned int D.19701;
  long unsigned int D.19702;
  long unsigned int D.19705;
  long unsigned int D.19706;
  long unsigned int D.19707;
  long unsigned int D.19708;
  long unsigned int D.19709;
  long unsigned int D.19710;
  char * D.19711;
  int D.19714;
  int D.19718;
  void * D.19721;
  int D.19722;
  struct SgenRemeberedSet * D.19727;
  gboolean (*<T2dda>) (char *) D.19728;
  int D.19729;
  int D.19732;
  long unsigned int D.19736;
  long unsigned int D.19737;
  int D.19740;
  int D.19744;
  int D.19747;
  struct SgenRemeberedSet * D.19752;
  gboolean (*<T2dda>) (char *) D.19753;
  int D.19754;
  int D.19757;
  long unsigned int D.19761;
  long unsigned int D.19762;
  int D.19763;
  char * D.19764;
  int D.19767;
  int D.19771;
  void * D.19774;
  int D.19775;
  struct SgenRemeberedSet * D.19780;
  gboolean (*<T2dda>) (char *) D.19781;
  int D.19782;
  int D.19785;
  long unsigned int D.19789;
  long unsigned int D.19790;
  long unsigned int D.19791;
  long unsigned int D.19792;
  int D.19793;
  int D.19796;
  int D.19800;
  int D.19803;
  struct SgenRemeberedSet * D.19808;
  gboolean (*<T2dda>) (char *) D.19809;
  int D.19810;
  int D.19813;
  long unsigned int D.19817;
  long unsigned int D.19820;
  int D.19821;
  int D.19822;
  unsigned int D.19825;
  unsigned int el_size.88;
  unsigned int D.19827;
  sizetype D.19828;
  char * D.19829;
  int D.19832;
  int D.19836;
  void * D.19839;
  int D.19840;
  struct SgenRemeberedSet * D.19845;
  gboolean (*<T2dda>) (char *) D.19846;
  int D.19847;
  int D.19850;
  long unsigned int D.19854;
  long unsigned int D.19855;
  int D.19859;
  int D.19860;
  long unsigned int D.19861;
  long unsigned int D.19862;
  char * D.19863;
  sizetype D.19864;
  char * D.19865;
  int D.19868;
  long unsigned int D.19871;
  long unsigned int D.19872;
  char * * D.19873;
  int D.19875;
  void * D.19878;
  void * D.19879;
  int D.19880;
  struct SgenRemeberedSet * D.19885;
  gboolean (*<T2dda>) (char *) D.19886;
  void * * D.19887;
  int D.19888;
  void * D.19891;
  int D.19892;
  long unsigned int D.19896;
  long unsigned int D.19897;
  sizetype D.19898;
  long unsigned int D.19902;
  char * D.19905;
  int D.19908;
  int D.19912;
  void * D.19915;
  int D.19916;
  struct SgenRemeberedSet * D.19921;
  gboolean (*<T2dda>) (char *) D.19922;
  int D.19923;
  int D.19926;
  long unsigned int D.19930;
  long unsigned int D.19931;
  long unsigned int D.19932;
  char * D.19935;
  int D.19938;
  int D.19942;
  void * D.19945;
  int D.19946;
  struct SgenRemeberedSet * D.19951;
  gboolean (*<T2dda>) (char *) D.19952;
  int D.19953;
  int D.19956;
  long unsigned int D.19960;
  long unsigned int D.19961;
  long unsigned int D.19962;
  unsigned int D.19963;
  unsigned int D.19964;
  struct MonoVTable * D.19967;
  struct MonoClass * D.19968;
  const char * D.19969;
  const char * D.19970;
  gsize * bitmap_data.89;
  long unsigned int D.19972;
  char * D.19975;
  int D.19978;
  int D.19982;
  void * D.19985;
  int D.19986;
  struct SgenRemeberedSet * D.19991;
  gboolean (*<T2dda>) (char *) D.19992;
  int D.19993;
  int D.19996;
  long unsigned int D.20000;
  long unsigned int D.20001;
  int bwords.90;
  long unsigned int D.20003;
  gsize * mbitmap_data.91;
  long unsigned int D.20005;
  unsigned int D.20006;
  unsigned int D.20007;
  struct MonoClass * D.20008;
  unsigned int el_size.92;
  unsigned int D.20010;
  sizetype D.20011;
  const char * D.20014;
  const char * D.20015;
  gsize * bitmap_data.93;
  long unsigned int D.20017;
  char * D.20020;
  int D.20023;
  int D.20027;
  void * D.20030;
  int D.20031;
  struct SgenRemeberedSet * D.20036;
  gboolean (*<T2dda>) (char *) D.20037;
  int D.20038;
  int D.20041;
  long unsigned int D.20045;
  long unsigned int D.20046;
  unsigned int bwords.94;
  sizetype D.20048;
  gboolean allow_missing_pinned;

  data.87 = (long int) data;
  allow_missing_pinned = (gboolean) data.87;
  {
    struct GCVTable * vt;
    mword desc;

    D.19699 = MEM[(mword *)start];
    D.19700 = D.19699 & 18446744073709551612;
    vt = (struct GCVTable *) D.19700;
    desc = vt->desc;
    D.19701 = desc & 7;
    switch (D.19701) <default: <D.18371>, case 1: <D.18286>, case 2: <D.18293>, case 3: <D.18337>, case 4: <D.18301>, case 5: <D.18331>, case 6: <D.18350>, case 7: <D.18370>>
    <D.18286>:
    D.19702 = desc & 4294901760;
    if (D.19702 != 0) goto <D.19703>; else goto <D.19704>;
    <D.19703>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19705 = desc >> 16;
      D.19706 = D.19705 & 255;
      D.19707 = D.19706 * 8;
      _objptr = _objptr + D.19707;
      D.19708 = desc >> 24;
      D.19709 = D.19708 & 255;
      D.19710 = D.19709 * 8;
      _objptr_end = _objptr + D.19710;
      D.19711 = MEM[(char * *)_objptr];
      if (D.19711 != 0B) goto <D.19712>; else goto <D.19713>;
      <D.19712>:
      D.19711 = MEM[(char * *)_objptr];
      D.19714 = is_valid_object_pointer (D.19711);
      if (D.19714 == 0) goto <D.19715>; else goto <D.19716>;
      <D.19715>:
      bad_pointer_spew (start, _objptr);
      goto <D.19717>;
      <D.19716>:
      D.19718 = sgen_ptr_in_nursery (start);
      if (D.19718 == 0) goto <D.19719>; else goto <D.19720>;
      <D.19719>:
      D.19721 = *_objptr;
      D.19722 = sgen_ptr_in_nursery (D.19721);
      if (D.19722 != 0) goto <D.19723>; else goto <D.19724>;
      <D.19723>:
      D.19727 = sgen_get_remset ();
      D.19728 = D.19727->find_address;
      D.19729 = D.19728 (_objptr);
      if (D.19729 == 0) goto <D.19730>; else goto <D.19731>;
      <D.19730>:
      D.19721 = *_objptr;
      D.19732 = sgen_cement_lookup (D.19721);
      if (D.19732 == 0) goto <D.19733>; else goto <D.19734>;
      <D.19733>:
      if (allow_missing_pinned == 0) goto <D.19725>; else goto <D.19735>;
      <D.19735>:
      D.19721 = *_objptr;
      D.19736 = MEM[(mword *)D.19721];
      D.19737 = D.19736 & 2;
      if (D.19737 == 0) goto <D.19725>; else goto <D.19726>;
      <D.19725>:
      missing_remset_spew (start, _objptr);
      <D.19726>:
      <D.19734>:
      <D.19731>:
      <D.19724>:
      <D.19720>:
      <D.19717>:
      <D.19713>:
      _objptr = _objptr + 8;
      goto <D.18290>;
      <D.18289>:
      D.19711 = MEM[(char * *)_objptr];
      if (D.19711 != 0B) goto <D.19738>; else goto <D.19739>;
      <D.19738>:
      D.19711 = MEM[(char * *)_objptr];
      D.19740 = is_valid_object_pointer (D.19711);
      if (D.19740 == 0) goto <D.19741>; else goto <D.19742>;
      <D.19741>:
      bad_pointer_spew (start, _objptr);
      goto <D.19743>;
      <D.19742>:
      D.19744 = sgen_ptr_in_nursery (start);
      if (D.19744 == 0) goto <D.19745>; else goto <D.19746>;
      <D.19745>:
      D.19721 = *_objptr;
      D.19747 = sgen_ptr_in_nursery (D.19721);
      if (D.19747 != 0) goto <D.19748>; else goto <D.19749>;
      <D.19748>:
      D.19752 = sgen_get_remset ();
      D.19753 = D.19752->find_address;
      D.19754 = D.19753 (_objptr);
      if (D.19754 == 0) goto <D.19755>; else goto <D.19756>;
      <D.19755>:
      D.19721 = *_objptr;
      D.19757 = sgen_cement_lookup (D.19721);
      if (D.19757 == 0) goto <D.19758>; else goto <D.19759>;
      <D.19758>:
      if (allow_missing_pinned == 0) goto <D.19750>; else goto <D.19760>;
      <D.19760>:
      D.19721 = *_objptr;
      D.19736 = MEM[(mword *)D.19721];
      D.19737 = D.19736 & 2;
      if (D.19737 == 0) goto <D.19750>; else goto <D.19751>;
      <D.19750>:
      missing_remset_spew (start, _objptr);
      <D.19751>:
      <D.19759>:
      <D.19756>:
      <D.19749>:
      <D.19746>:
      <D.19743>:
      <D.19739>:
      _objptr = _objptr + 8;
      <D.18290>:
      if (_objptr < _objptr_end) goto <D.18289>; else goto <D.18291>;
      <D.18291>:
    }
    <D.19704>:
    goto <D.18292>;
    <D.18293>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.19761 = (long unsigned int) _index;
        D.19762 = D.19761 * 8;
        _objptr = _objptr + D.19762;
        D.19763 = _index + 1;
        _bmap = _bmap >> D.19763;
        D.19764 = MEM[(char * *)_objptr];
        if (D.19764 != 0B) goto <D.19765>; else goto <D.19766>;
        <D.19765>:
        D.19764 = MEM[(char * *)_objptr];
        D.19767 = is_valid_object_pointer (D.19764);
        if (D.19767 == 0) goto <D.19768>; else goto <D.19769>;
        <D.19768>:
        bad_pointer_spew (start, _objptr);
        goto <D.19770>;
        <D.19769>:
        D.19771 = sgen_ptr_in_nursery (start);
        if (D.19771 == 0) goto <D.19772>; else goto <D.19773>;
        <D.19772>:
        D.19774 = *_objptr;
        D.19775 = sgen_ptr_in_nursery (D.19774);
        if (D.19775 != 0) goto <D.19776>; else goto <D.19777>;
        <D.19776>:
        D.19780 = sgen_get_remset ();
        D.19781 = D.19780->find_address;
        D.19782 = D.19781 (_objptr);
        if (D.19782 == 0) goto <D.19783>; else goto <D.19784>;
        <D.19783>:
        D.19774 = *_objptr;
        D.19785 = sgen_cement_lookup (D.19774);
        if (D.19785 == 0) goto <D.19786>; else goto <D.19787>;
        <D.19786>:
        if (allow_missing_pinned == 0) goto <D.19778>; else goto <D.19788>;
        <D.19788>:
        D.19774 = *_objptr;
        D.19789 = MEM[(mword *)D.19774];
        D.19790 = D.19789 & 2;
        if (D.19790 == 0) goto <D.19778>; else goto <D.19779>;
        <D.19778>:
        missing_remset_spew (start, _objptr);
        <D.19779>:
        <D.19787>:
        <D.19784>:
        <D.19777>:
        <D.19773>:
        <D.19770>:
        <D.19766>:
        _objptr = _objptr + 8;
      }
      goto <D.18299>;
      <D.18298>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.19791 = (long unsigned int) _index;
        D.19792 = D.19791 * 8;
        _objptr = _objptr + D.19792;
        D.19793 = _index + 1;
        _bmap = _bmap >> D.19793;
        D.19764 = MEM[(char * *)_objptr];
        if (D.19764 != 0B) goto <D.19794>; else goto <D.19795>;
        <D.19794>:
        D.19764 = MEM[(char * *)_objptr];
        D.19796 = is_valid_object_pointer (D.19764);
        if (D.19796 == 0) goto <D.19797>; else goto <D.19798>;
        <D.19797>:
        bad_pointer_spew (start, _objptr);
        goto <D.19799>;
        <D.19798>:
        D.19800 = sgen_ptr_in_nursery (start);
        if (D.19800 == 0) goto <D.19801>; else goto <D.19802>;
        <D.19801>:
        D.19774 = *_objptr;
        D.19803 = sgen_ptr_in_nursery (D.19774);
        if (D.19803 != 0) goto <D.19804>; else goto <D.19805>;
        <D.19804>:
        D.19808 = sgen_get_remset ();
        D.19809 = D.19808->find_address;
        D.19810 = D.19809 (_objptr);
        if (D.19810 == 0) goto <D.19811>; else goto <D.19812>;
        <D.19811>:
        D.19774 = *_objptr;
        D.19813 = sgen_cement_lookup (D.19774);
        if (D.19813 == 0) goto <D.19814>; else goto <D.19815>;
        <D.19814>:
        if (allow_missing_pinned == 0) goto <D.19806>; else goto <D.19816>;
        <D.19816>:
        D.19774 = *_objptr;
        D.19789 = MEM[(mword *)D.19774];
        D.19790 = D.19789 & 2;
        if (D.19790 == 0) goto <D.19806>; else goto <D.19807>;
        <D.19806>:
        missing_remset_spew (start, _objptr);
        <D.19807>:
        <D.19815>:
        <D.19812>:
        <D.19805>:
        <D.19802>:
        <D.19799>:
        <D.19795>:
        _objptr = _objptr + 8;
      }
      <D.18299>:
      if (_bmap != 0) goto <D.18298>; else goto <D.18300>;
      <D.18300>:
    }
    goto <D.18292>;
    <D.18301>:
    D.19817 = desc & 4294950912;
    if (D.19817 != 0) goto <D.19818>; else goto <D.19819>;
    <D.19818>:
    {
      int el_size;
      int etype;

      D.19820 = desc >> 3;
      D.19821 = (int) D.19820;
      el_size = D.19821 & 1023;
      D.19822 = (int) desc;
      etype = D.19822 & 49152;
      if (etype == 16384) goto <D.19823>; else goto <D.19824>;
      <D.19823>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.19825 = MEM[(struct MonoArray *)start].max_length;
        el_size.88 = (unsigned int) el_size;
        D.19827 = D.19825 * el_size.88;
        D.19828 = (sizetype) D.19827;
        end_refs = p + D.19828;
        goto <D.18307>;
        <D.18306>:
        D.19829 = MEM[(char * *)p];
        if (D.19829 != 0B) goto <D.19830>; else goto <D.19831>;
        <D.19830>:
        D.19829 = MEM[(char * *)p];
        D.19832 = is_valid_object_pointer (D.19829);
        if (D.19832 == 0) goto <D.19833>; else goto <D.19834>;
        <D.19833>:
        bad_pointer_spew (start, p);
        goto <D.19835>;
        <D.19834>:
        D.19836 = sgen_ptr_in_nursery (start);
        if (D.19836 == 0) goto <D.19837>; else goto <D.19838>;
        <D.19837>:
        D.19839 = *p;
        D.19840 = sgen_ptr_in_nursery (D.19839);
        if (D.19840 != 0) goto <D.19841>; else goto <D.19842>;
        <D.19841>:
        D.19845 = sgen_get_remset ();
        D.19846 = D.19845->find_address;
        D.19847 = D.19846 (p);
        if (D.19847 == 0) goto <D.19848>; else goto <D.19849>;
        <D.19848>:
        D.19839 = *p;
        D.19850 = sgen_cement_lookup (D.19839);
        if (D.19850 == 0) goto <D.19851>; else goto <D.19852>;
        <D.19851>:
        if (allow_missing_pinned == 0) goto <D.19843>; else goto <D.19853>;
        <D.19853>:
        D.19839 = *p;
        D.19854 = MEM[(mword *)D.19839];
        D.19855 = D.19854 & 2;
        if (D.19855 == 0) goto <D.19843>; else goto <D.19844>;
        <D.19843>:
        missing_remset_spew (start, p);
        <D.19844>:
        <D.19852>:
        <D.19849>:
        <D.19842>:
        <D.19838>:
        <D.19835>:
        <D.19831>:
        p = p + 8;
        <D.18307>:
        if (p < end_refs) goto <D.18306>; else goto <D.18308>;
        <D.18308>:
      }
      goto <D.19856>;
      <D.19824>:
      if (etype == 32768) goto <D.19857>; else goto <D.19858>;
      <D.19857>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19705 = desc >> 16;
        D.19859 = (int) D.19705;
        offset = D.19859 & 255;
        D.19708 = desc >> 24;
        D.19860 = (int) D.19708;
        num_refs = D.19860 & 255;
        e_start = start + 32;
        D.19825 = MEM[(struct MonoArray *)start].max_length;
        el_size.88 = (unsigned int) el_size;
        D.19827 = D.19825 * el_size.88;
        D.19828 = (sizetype) D.19827;
        e_end = e_start + D.19828;
        goto <D.18319>;
        <D.18318>:
        {
          void * * p;
          int i;

          p = e_start;
          D.19861 = (long unsigned int) offset;
          D.19862 = D.19861 * 8;
          p = p + D.19862;
          i = 0;
          goto <D.18316>;
          <D.18315>:
          D.19863 = MEM[(char * *)p];
          D.19864 = (sizetype) i;
          D.19865 = D.19863 + D.19864;
          if (D.19865 != 0B) goto <D.19866>; else goto <D.19867>;
          <D.19866>:
          D.19863 = MEM[(char * *)p];
          D.19864 = (sizetype) i;
          D.19865 = D.19863 + D.19864;
          D.19868 = is_valid_object_pointer (D.19865);
          if (D.19868 == 0) goto <D.19869>; else goto <D.19870>;
          <D.19869>:
          D.19871 = (long unsigned int) i;
          D.19872 = D.19871 * 8;
          D.19873 = p + D.19872;
          bad_pointer_spew (start, D.19873);
          goto <D.19874>;
          <D.19870>:
          D.19875 = sgen_ptr_in_nursery (start);
          if (D.19875 == 0) goto <D.19876>; else goto <D.19877>;
          <D.19876>:
          D.19878 = *p;
          D.19864 = (sizetype) i;
          D.19879 = D.19878 + D.19864;
          D.19880 = sgen_ptr_in_nursery (D.19879);
          if (D.19880 != 0) goto <D.19881>; else goto <D.19882>;
          <D.19881>:
          D.19885 = sgen_get_remset ();
          D.19886 = D.19885->find_address;
          D.19871 = (long unsigned int) i;
          D.19872 = D.19871 * 8;
          D.19887 = p + D.19872;
          D.19888 = D.19886 (D.19887);
          if (D.19888 == 0) goto <D.19889>; else goto <D.19890>;
          <D.19889>:
          D.19871 = (long unsigned int) i;
          D.19872 = D.19871 * 8;
          D.19887 = p + D.19872;
          D.19891 = *D.19887;
          D.19892 = sgen_cement_lookup (D.19891);
          if (D.19892 == 0) goto <D.19893>; else goto <D.19894>;
          <D.19893>:
          if (allow_missing_pinned == 0) goto <D.19883>; else goto <D.19895>;
          <D.19895>:
          D.19871 = (long unsigned int) i;
          D.19872 = D.19871 * 8;
          D.19887 = p + D.19872;
          D.19891 = *D.19887;
          D.19896 = MEM[(mword *)D.19891];
          D.19897 = D.19896 & 2;
          if (D.19897 == 0) goto <D.19883>; else goto <D.19884>;
          <D.19883>:
          D.19871 = (long unsigned int) i;
          D.19872 = D.19871 * 8;
          D.19873 = p + D.19872;
          missing_remset_spew (start, D.19873);
          <D.19884>:
          <D.19894>:
          <D.19890>:
          <D.19882>:
          <D.19877>:
          <D.19874>:
          <D.19867>:
          i = i + 1;
          <D.18316>:
          if (i < num_refs) goto <D.18315>; else goto <D.18317>;
          <D.18317>:
          D.19898 = (sizetype) el_size;
          e_start = e_start + D.19898;
        }
        <D.18319>:
        if (e_start < e_end) goto <D.18318>; else goto <D.18320>;
        <D.18320>:
      }
      goto <D.19899>;
      <D.19858>:
      if (etype == 49152) goto <D.19900>; else goto <D.19901>;
      <D.19900>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.19825 = MEM[(struct MonoArray *)start].max_length;
        el_size.88 = (unsigned int) el_size;
        D.19827 = D.19825 * el_size.88;
        D.19828 = (sizetype) D.19827;
        e_end = e_start + D.19828;
        goto <D.18329>;
        <D.18328>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.18326>;
          <D.18325>:
          D.19902 = _bmap & 1;
          if (D.19902 != 0) goto <D.19903>; else goto <D.19904>;
          <D.19903>:
          D.19905 = MEM[(char * *)p];
          if (D.19905 != 0B) goto <D.19906>; else goto <D.19907>;
          <D.19906>:
          D.19905 = MEM[(char * *)p];
          D.19908 = is_valid_object_pointer (D.19905);
          if (D.19908 == 0) goto <D.19909>; else goto <D.19910>;
          <D.19909>:
          bad_pointer_spew (start, p);
          goto <D.19911>;
          <D.19910>:
          D.19912 = sgen_ptr_in_nursery (start);
          if (D.19912 == 0) goto <D.19913>; else goto <D.19914>;
          <D.19913>:
          D.19915 = *p;
          D.19916 = sgen_ptr_in_nursery (D.19915);
          if (D.19916 != 0) goto <D.19917>; else goto <D.19918>;
          <D.19917>:
          D.19921 = sgen_get_remset ();
          D.19922 = D.19921->find_address;
          D.19923 = D.19922 (p);
          if (D.19923 == 0) goto <D.19924>; else goto <D.19925>;
          <D.19924>:
          D.19915 = *p;
          D.19926 = sgen_cement_lookup (D.19915);
          if (D.19926 == 0) goto <D.19927>; else goto <D.19928>;
          <D.19927>:
          if (allow_missing_pinned == 0) goto <D.19919>; else goto <D.19929>;
          <D.19929>:
          D.19915 = *p;
          D.19930 = MEM[(mword *)D.19915];
          D.19931 = D.19930 & 2;
          if (D.19931 == 0) goto <D.19919>; else goto <D.19920>;
          <D.19919>:
          missing_remset_spew (start, p);
          <D.19920>:
          <D.19928>:
          <D.19925>:
          <D.19918>:
          <D.19914>:
          <D.19911>:
          <D.19907>:
          <D.19904>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.18326>:
          if (_bmap != 0) goto <D.18325>; else goto <D.18327>;
          <D.18327>:
          D.19898 = (sizetype) el_size;
          e_start = e_start + D.19898;
        }
        <D.18329>:
        if (e_start < e_end) goto <D.18328>; else goto <D.18330>;
        <D.18330>:
      }
      <D.19901>:
      <D.19899>:
      <D.19856>:
    }
    <D.19819>:
    goto <D.18292>;
    <D.18331>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.18335>;
      <D.18334>:
      D.19932 = _bmap & 1;
      if (D.19932 != 0) goto <D.19933>; else goto <D.19934>;
      <D.19933>:
      D.19935 = MEM[(char * *)_objptr];
      if (D.19935 != 0B) goto <D.19936>; else goto <D.19937>;
      <D.19936>:
      D.19935 = MEM[(char * *)_objptr];
      D.19938 = is_valid_object_pointer (D.19935);
      if (D.19938 == 0) goto <D.19939>; else goto <D.19940>;
      <D.19939>:
      bad_pointer_spew (start, _objptr);
      goto <D.19941>;
      <D.19940>:
      D.19942 = sgen_ptr_in_nursery (start);
      if (D.19942 == 0) goto <D.19943>; else goto <D.19944>;
      <D.19943>:
      D.19945 = *_objptr;
      D.19946 = sgen_ptr_in_nursery (D.19945);
      if (D.19946 != 0) goto <D.19947>; else goto <D.19948>;
      <D.19947>:
      D.19951 = sgen_get_remset ();
      D.19952 = D.19951->find_address;
      D.19953 = D.19952 (_objptr);
      if (D.19953 == 0) goto <D.19954>; else goto <D.19955>;
      <D.19954>:
      D.19945 = *_objptr;
      D.19956 = sgen_cement_lookup (D.19945);
      if (D.19956 == 0) goto <D.19957>; else goto <D.19958>;
      <D.19957>:
      if (allow_missing_pinned == 0) goto <D.19949>; else goto <D.19959>;
      <D.19959>:
      D.19945 = *_objptr;
      D.19960 = MEM[(mword *)D.19945];
      D.19961 = D.19960 & 2;
      if (D.19961 == 0) goto <D.19949>; else goto <D.19950>;
      <D.19949>:
      missing_remset_spew (start, _objptr);
      <D.19950>:
      <D.19958>:
      <D.19955>:
      <D.19948>:
      <D.19944>:
      <D.19941>:
      <D.19937>:
      <D.19934>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18335>:
      if (_bmap != 0) goto <D.18334>; else goto <D.18336>;
      <D.18336>:
    }
    goto <D.18292>;
    <D.18337>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19962 = *bitmap_data;
      D.19963 = (unsigned int) D.19962;
      D.19964 = D.19963 + 4294967295;
      bwords = (int) D.19964;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.19965>; else goto <D.19966>;
      <D.19965>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19967 = myobj->vtable;
        D.19968 = D.19967->klass;
        D.19969 = D.19968->name_space;
        D.19967 = myobj->vtable;
        D.19968 = D.19967->klass;
        D.19970 = D.19968->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19969, D.19970);
      }
      <D.19966>:
      goto <D.18348>;
      <D.18347>:
      {
        gsize _bmap;

        bitmap_data.89 = bitmap_data;
        bitmap_data = bitmap_data.89 + 8;
        _bmap = *bitmap_data.89;
        _objptr = start_run;
        goto <D.18345>;
        <D.18344>:
        D.19972 = _bmap & 1;
        if (D.19972 != 0) goto <D.19973>; else goto <D.19974>;
        <D.19973>:
        D.19975 = MEM[(char * *)_objptr];
        if (D.19975 != 0B) goto <D.19976>; else goto <D.19977>;
        <D.19976>:
        D.19975 = MEM[(char * *)_objptr];
        D.19978 = is_valid_object_pointer (D.19975);
        if (D.19978 == 0) goto <D.19979>; else goto <D.19980>;
        <D.19979>:
        bad_pointer_spew (start, _objptr);
        goto <D.19981>;
        <D.19980>:
        D.19982 = sgen_ptr_in_nursery (start);
        if (D.19982 == 0) goto <D.19983>; else goto <D.19984>;
        <D.19983>:
        D.19985 = *_objptr;
        D.19986 = sgen_ptr_in_nursery (D.19985);
        if (D.19986 != 0) goto <D.19987>; else goto <D.19988>;
        <D.19987>:
        D.19991 = sgen_get_remset ();
        D.19992 = D.19991->find_address;
        D.19993 = D.19992 (_objptr);
        if (D.19993 == 0) goto <D.19994>; else goto <D.19995>;
        <D.19994>:
        D.19985 = *_objptr;
        D.19996 = sgen_cement_lookup (D.19985);
        if (D.19996 == 0) goto <D.19997>; else goto <D.19998>;
        <D.19997>:
        if (allow_missing_pinned == 0) goto <D.19989>; else goto <D.19999>;
        <D.19999>:
        D.19985 = *_objptr;
        D.20000 = MEM[(mword *)D.19985];
        D.20001 = D.20000 & 2;
        if (D.20001 == 0) goto <D.19989>; else goto <D.19990>;
        <D.19989>:
        missing_remset_spew (start, _objptr);
        <D.19990>:
        <D.19998>:
        <D.19995>:
        <D.19988>:
        <D.19984>:
        <D.19981>:
        <D.19977>:
        <D.19974>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18345>:
        if (_bmap != 0) goto <D.18344>; else goto <D.18346>;
        <D.18346>:
        start_run = start_run + 512;
      }
      <D.18348>:
      bwords.90 = bwords;
      bwords = bwords.90 + -1;
      if (bwords.90 > 0) goto <D.18347>; else goto <D.18349>;
      <D.18349>:
    }
    goto <D.18292>;
    <D.18350>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.20003 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.20003);
      mbitmap_data.91 = mbitmap_data;
      mbitmap_data = mbitmap_data.91 + 8;
      D.20005 = *mbitmap_data.91;
      D.20006 = (unsigned int) D.20005;
      D.20007 = D.20006 + 4294967295;
      mbwords = (int) D.20007;
      D.20008 = vt->klass;
      el_size = mono_array_element_size (D.20008);
      e_start = start + 32;
      D.19825 = MEM[(struct MonoArray *)start].max_length;
      el_size.92 = (unsigned int) el_size;
      D.20010 = D.19825 * el_size.92;
      D.20011 = (sizetype) D.20010;
      e_end = e_start + D.20011;
      if (0 != 0) goto <D.20012>; else goto <D.20013>;
      <D.20012>:
      D.20003 = vt->desc;
      D.20008 = vt->klass;
      D.20014 = D.20008->name_space;
      D.20008 = vt->klass;
      D.20015 = D.20008->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.20003, D.20014, D.20015);
      <D.20013>:
      goto <D.18368>;
      <D.18367>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.93 = bitmap_data;
          bitmap_data = bitmap_data.93 + 8;
          _bmap = *bitmap_data.93;
          start_run = _objptr;
          goto <D.18362>;
          <D.18361>:
          D.20017 = _bmap & 1;
          if (D.20017 != 0) goto <D.20018>; else goto <D.20019>;
          <D.20018>:
          D.20020 = MEM[(char * *)_objptr];
          if (D.20020 != 0B) goto <D.20021>; else goto <D.20022>;
          <D.20021>:
          D.20020 = MEM[(char * *)_objptr];
          D.20023 = is_valid_object_pointer (D.20020);
          if (D.20023 == 0) goto <D.20024>; else goto <D.20025>;
          <D.20024>:
          bad_pointer_spew (start, _objptr);
          goto <D.20026>;
          <D.20025>:
          D.20027 = sgen_ptr_in_nursery (start);
          if (D.20027 == 0) goto <D.20028>; else goto <D.20029>;
          <D.20028>:
          D.20030 = *_objptr;
          D.20031 = sgen_ptr_in_nursery (D.20030);
          if (D.20031 != 0) goto <D.20032>; else goto <D.20033>;
          <D.20032>:
          D.20036 = sgen_get_remset ();
          D.20037 = D.20036->find_address;
          D.20038 = D.20037 (_objptr);
          if (D.20038 == 0) goto <D.20039>; else goto <D.20040>;
          <D.20039>:
          D.20030 = *_objptr;
          D.20041 = sgen_cement_lookup (D.20030);
          if (D.20041 == 0) goto <D.20042>; else goto <D.20043>;
          <D.20042>:
          if (allow_missing_pinned == 0) goto <D.20034>; else goto <D.20044>;
          <D.20044>:
          D.20030 = *_objptr;
          D.20045 = MEM[(mword *)D.20030];
          D.20046 = D.20045 & 2;
          if (D.20046 == 0) goto <D.20034>; else goto <D.20035>;
          <D.20034>:
          missing_remset_spew (start, _objptr);
          <D.20035>:
          <D.20043>:
          <D.20040>:
          <D.20033>:
          <D.20029>:
          <D.20026>:
          <D.20022>:
          <D.20019>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18362>:
          if (_bmap != 0) goto <D.18361>; else goto <D.18363>;
          <D.18363>:
          _objptr = start_run + 512;
        }
        <D.18365>:
        bwords.94 = bwords;
        bwords = bwords.94 + 4294967295;
        if (bwords.94 != 0) goto <D.18364>; else goto <D.18366>;
        <D.18366>:
        D.20048 = (sizetype) el_size;
        e_start = e_start + D.20048;
      }
      <D.18368>:
      if (e_start < e_end) goto <D.18367>; else goto <D.18369>;
      <D.18369>:
    }
    goto <D.18292>;
    <D.18370>:
    goto <D.18292>;
    <D.18371>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.18292>:
  }
}


is_valid_object_pointer (char * object)
{
  int D.20050;
  gboolean D.20053;
  int D.20054;
  gboolean (*<T2dda>) (char *) D.20057;
  int D.20058;

  D.20050 = sgen_ptr_in_nursery (object);
  if (D.20050 != 0) goto <D.20051>; else goto <D.20052>;
  <D.20051>:
  D.20053 = find_object_in_nursery_dump (object);
  return D.20053;
  <D.20052>:
  D.20054 = sgen_los_is_valid_object (object);
  if (D.20054 != 0) goto <D.20055>; else goto <D.20056>;
  <D.20055>:
  D.20053 = 1;
  return D.20053;
  <D.20056>:
  D.20057 = major_collector.is_valid_object;
  D.20058 = D.20057 (object);
  if (D.20058 != 0) goto <D.20059>; else goto <D.20060>;
  <D.20059>:
  D.20053 = 1;
  return D.20053;
  <D.20060>:
  D.20053 = 0;
  return D.20053;
}


find_object_in_nursery_dump (char * object)
{
  int D.20062;
  int D.20063;
  char * * valid_nursery_objects.95;
  long unsigned int D.20065;
  long unsigned int D.20066;
  char * * D.20067;
  char * D.20068;
  gboolean D.20071;
  _Bool D.20075;
  long int D.20076;
  long int D.20077;
  int first;
  int last;

  first = 0;
  last = valid_nursery_object_count;
  goto <D.18252>;
  <D.18251>:
  {
    int middle;

    D.20062 = last - first;
    D.20063 = D.20062 >> 1;
    middle = D.20063 + first;
    valid_nursery_objects.95 = valid_nursery_objects;
    D.20065 = (long unsigned int) middle;
    D.20066 = D.20065 * 8;
    D.20067 = valid_nursery_objects.95 + D.20066;
    D.20068 = *D.20067;
    if (D.20068 == object) goto <D.20069>; else goto <D.20070>;
    <D.20069>:
    D.20071 = 1;
    return D.20071;
    <D.20070>:
    valid_nursery_objects.95 = valid_nursery_objects;
    D.20065 = (long unsigned int) middle;
    D.20066 = D.20065 * 8;
    D.20067 = valid_nursery_objects.95 + D.20066;
    D.20068 = *D.20067;
    if (D.20068 > object) goto <D.20072>; else goto <D.20073>;
    <D.20072>:
    last = middle;
    goto <D.20074>;
    <D.20073>:
    first = middle + 1;
    <D.20074>:
  }
  <D.18252>:
  if (first < last) goto <D.18251>; else goto <D.18253>;
  <D.18253>:
  D.20075 = first != last;
  D.20076 = (long int) D.20075;
  D.20077 = __builtin_expect (D.20076, 0);
  if (D.20077 != 0) goto <D.20078>; else goto <D.20079>;
  <D.20078>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 337, "first == last");
  <D.20079>:
  D.20071 = 0;
  return D.20071;
}


bad_pointer_spew (char * obj, char * * slot)
{
  long unsigned int D.20081;
  long unsigned int D.20082;
  int gc_debug_level.96;
  _Bool D.20084;
  long int D.20085;
  long int D.20086;
  struct FILE * gc_debug_file.97;
  long int slot.98;
  long int obj.99;
  long int D.20092;
  struct MonoClass * D.20093;
  const char * D.20094;
  const char * D.20095;
  char * ptr;
  struct MonoVTable * vtable;

  ptr = *slot;
  D.20081 = MEM[(mword *)obj];
  D.20082 = D.20081 & 18446744073709551612;
  vtable = (struct MonoVTable *) D.20082;
  gc_debug_level.96 = gc_debug_level;
  D.20084 = gc_debug_level.96 >= 0;
  D.20085 = (long int) D.20084;
  D.20086 = __builtin_expect (D.20085, 0);
  if (D.20086 != 0) goto <D.20087>; else goto <D.20088>;
  <D.20087>:
  gc_debug_file.97 = gc_debug_file;
  slot.98 = (long int) slot;
  obj.99 = (long int) obj;
  D.20092 = slot.98 - obj.99;
  D.20093 = vtable->klass;
  D.20094 = D.20093->name_space;
  D.20093 = vtable->klass;
  D.20095 = D.20093->name;
  fprintf (gc_debug_file.97, "Invalid object pointer %p at offset %td in object %p (%s.%s):\n", ptr, D.20092, obj, D.20094, D.20095);
  gc_debug_file.97 = gc_debug_file;
  fflush (gc_debug_file.97);
  <D.20088>:
  describe_pointer (ptr, 0);
  broken_heap = 1;
}


missing_remset_spew (char * obj, char * * slot)
{
  long unsigned int D.20096;
  long unsigned int D.20097;
  int gc_debug_level.100;
  _Bool D.20099;
  long int D.20100;
  long int D.20101;
  struct FILE * gc_debug_file.101;
  long int slot.102;
  long int obj.103;
  long int D.20107;
  struct MonoClass * D.20108;
  const char * D.20109;
  const char * D.20110;
  char * ptr;
  struct MonoVTable * vtable;

  ptr = *slot;
  D.20096 = MEM[(mword *)obj];
  D.20097 = D.20096 & 18446744073709551612;
  vtable = (struct MonoVTable *) D.20097;
  gc_debug_level.100 = gc_debug_level;
  D.20099 = gc_debug_level.100 >= 0;
  D.20100 = (long int) D.20099;
  D.20101 = __builtin_expect (D.20100, 0);
  if (D.20101 != 0) goto <D.20102>; else goto <D.20103>;
  <D.20102>:
  gc_debug_file.101 = gc_debug_file;
  slot.102 = (long int) slot;
  obj.103 = (long int) obj;
  D.20107 = slot.102 - obj.103;
  D.20108 = vtable->klass;
  D.20109 = D.20108->name_space;
  D.20108 = vtable->klass;
  D.20110 = D.20108->name;
  fprintf (gc_debug_file.101, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", ptr, D.20107, obj, D.20109, D.20110);
  gc_debug_file.101 = gc_debug_file;
  fflush (gc_debug_file.101);
  <D.20103>:
  broken_heap = 1;
}


sgen_check_objref (char * obj)
{
  int D.20111;
  _Bool D.20112;
  long int D.20113;
  long int D.20114;

  D.20111 = ptr_in_heap (obj);
  D.20112 = D.20111 == 0;
  D.20113 = (long int) D.20112;
  D.20114 = __builtin_expect (D.20113, 0);
  if (D.20114 != 0) goto <D.20115>; else goto <D.20116>;
  <D.20115>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 469, "ptr_in_heap (obj)");
  <D.20116>:
}


ptr_in_heap (char * object)
{
  int D.20117;
  gboolean D.20120;
  int D.20121;
  gboolean (*<T2dda>) (char *) D.20124;
  int D.20125;

  D.20117 = sgen_ptr_in_nursery (object);
  if (D.20117 != 0) goto <D.20118>; else goto <D.20119>;
  <D.20118>:
  D.20120 = 1;
  return D.20120;
  <D.20119>:
  D.20121 = sgen_los_is_valid_object (object);
  if (D.20121 != 0) goto <D.20122>; else goto <D.20123>;
  <D.20122>:
  D.20120 = 1;
  return D.20120;
  <D.20123>:
  D.20124 = major_collector.is_valid_object;
  D.20125 = D.20124 (object);
  if (D.20125 != 0) goto <D.20126>; else goto <D.20127>;
  <D.20126>:
  D.20120 = 1;
  return D.20120;
  <D.20127>:
  D.20120 = 0;
  return D.20120;
}


__attribute__((visibility ("hidden")))
sgen_check_major_heap_marked ()
{
  void (*<T2e34>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.20129;

  setup_valid_nursery_objects ();
  D.20129 = major_collector.iterate_objects;
  D.20129 (1, 1, check_marked_callback, 0B);
  sgen_los_iterate_objects (check_marked_callback, 1B);
}


check_marked_callback (char * start, size_t size, void * dummy)
{
  long int dummy.104;
  int D.20133;
  gboolean (*<T2dda>) (char *) D.20137;
  int D.20138;
  long unsigned int D.20141;
  long unsigned int D.20142;
  long unsigned int D.20143;
  long unsigned int D.20144;
  long unsigned int D.20147;
  long unsigned int D.20148;
  long unsigned int D.20149;
  long unsigned int D.20150;
  long unsigned int D.20151;
  long unsigned int D.20152;
  int D.20155;
  _Bool D.20156;
  long int D.20157;
  long int D.20158;
  int D.20161;
  long unsigned int D.20164;
  long unsigned int D.20165;
  _Bool D.20166;
  long int D.20167;
  long int D.20168;
  int D.20172;
  int D.20175;
  _Bool D.20176;
  long int D.20177;
  long int D.20178;
  gboolean (*<T2dda>) (char *) D.20182;
  int D.20183;
  int D.20186;
  _Bool D.20187;
  long int D.20188;
  long int D.20189;
  int D.20195;
  _Bool D.20196;
  long int D.20197;
  long int D.20198;
  int D.20201;
  long unsigned int D.20204;
  long unsigned int D.20205;
  _Bool D.20206;
  long int D.20207;
  long int D.20208;
  int D.20212;
  int D.20215;
  _Bool D.20216;
  long int D.20217;
  long int D.20218;
  int D.20222;
  int D.20225;
  _Bool D.20226;
  long int D.20227;
  long int D.20228;
  long unsigned int D.20232;
  long unsigned int D.20233;
  int D.20234;
  int D.20237;
  _Bool D.20238;
  long int D.20239;
  long int D.20240;
  int D.20243;
  long unsigned int D.20246;
  long unsigned int D.20247;
  _Bool D.20248;
  long int D.20249;
  long int D.20250;
  int D.20254;
  int D.20257;
  _Bool D.20258;
  long int D.20259;
  long int D.20260;
  int D.20264;
  int D.20267;
  _Bool D.20268;
  long int D.20269;
  long int D.20270;
  long unsigned int D.20274;
  long unsigned int D.20275;
  int D.20276;
  int D.20279;
  _Bool D.20280;
  long int D.20281;
  long int D.20282;
  int D.20285;
  long unsigned int D.20288;
  long unsigned int D.20289;
  _Bool D.20290;
  long int D.20291;
  long int D.20292;
  int D.20296;
  int D.20299;
  _Bool D.20300;
  long int D.20301;
  long int D.20302;
  int D.20306;
  int D.20309;
  _Bool D.20310;
  long int D.20311;
  long int D.20312;
  long unsigned int D.20316;
  long unsigned int D.20319;
  int D.20320;
  int D.20321;
  unsigned int D.20324;
  unsigned int el_size.105;
  unsigned int D.20326;
  sizetype D.20327;
  int D.20330;
  _Bool D.20331;
  long int D.20332;
  long int D.20333;
  int D.20336;
  long unsigned int D.20339;
  long unsigned int D.20340;
  _Bool D.20341;
  long int D.20342;
  long int D.20343;
  int D.20347;
  int D.20350;
  _Bool D.20351;
  long int D.20352;
  long int D.20353;
  int D.20357;
  int D.20360;
  _Bool D.20361;
  long int D.20362;
  long int D.20363;
  int D.20370;
  int D.20371;
  long unsigned int D.20372;
  long unsigned int D.20373;
  char * D.20374;
  sizetype D.20375;
  int D.20378;
  _Bool D.20379;
  long int D.20380;
  long int D.20381;
  int D.20384;
  long unsigned int D.20387;
  long unsigned int D.20388;
  _Bool D.20389;
  long int D.20390;
  long int D.20391;
  int D.20395;
  int D.20398;
  _Bool D.20399;
  long int D.20400;
  long int D.20401;
  int D.20405;
  int D.20408;
  _Bool D.20409;
  long int D.20410;
  long int D.20411;
  sizetype D.20415;
  long unsigned int D.20419;
  int D.20424;
  _Bool D.20425;
  long int D.20426;
  long int D.20427;
  int D.20430;
  long unsigned int D.20433;
  long unsigned int D.20434;
  _Bool D.20435;
  long int D.20436;
  long int D.20437;
  int D.20441;
  int D.20444;
  _Bool D.20445;
  long int D.20446;
  long int D.20447;
  int D.20451;
  int D.20454;
  _Bool D.20455;
  long int D.20456;
  long int D.20457;
  long unsigned int D.20461;
  int D.20466;
  _Bool D.20467;
  long int D.20468;
  long int D.20469;
  int D.20472;
  long unsigned int D.20475;
  long unsigned int D.20476;
  _Bool D.20477;
  long int D.20478;
  long int D.20479;
  int D.20483;
  int D.20486;
  _Bool D.20487;
  long int D.20488;
  long int D.20489;
  int D.20493;
  int D.20496;
  _Bool D.20497;
  long int D.20498;
  long int D.20499;
  long unsigned int D.20503;
  unsigned int D.20504;
  unsigned int D.20505;
  struct MonoVTable * D.20508;
  struct MonoClass * D.20509;
  const char * D.20510;
  const char * D.20511;
  gsize * bitmap_data.106;
  long unsigned int D.20513;
  int D.20518;
  _Bool D.20519;
  long int D.20520;
  long int D.20521;
  int D.20524;
  long unsigned int D.20527;
  long unsigned int D.20528;
  _Bool D.20529;
  long int D.20530;
  long int D.20531;
  int D.20535;
  int D.20538;
  _Bool D.20539;
  long int D.20540;
  long int D.20541;
  int D.20545;
  int D.20548;
  _Bool D.20549;
  long int D.20550;
  long int D.20551;
  int bwords.107;
  long unsigned int D.20556;
  gsize * mbitmap_data.108;
  long unsigned int D.20558;
  unsigned int D.20559;
  unsigned int D.20560;
  struct MonoClass * D.20561;
  unsigned int el_size.109;
  unsigned int D.20563;
  sizetype D.20564;
  const char * D.20567;
  const char * D.20568;
  gsize * bitmap_data.110;
  long unsigned int D.20570;
  int D.20575;
  _Bool D.20576;
  long int D.20577;
  long int D.20578;
  int D.20581;
  long unsigned int D.20584;
  long unsigned int D.20585;
  _Bool D.20586;
  long int D.20587;
  long int D.20588;
  int D.20592;
  int D.20595;
  _Bool D.20596;
  long int D.20597;
  long int D.20598;
  int D.20602;
  int D.20605;
  _Bool D.20606;
  long int D.20607;
  long int D.20608;
  unsigned int bwords.111;
  sizetype D.20613;
  gboolean is_los;

  dummy.104 = (long int) dummy;
  is_los = (gboolean) dummy.104;
  if (is_los != 0) goto <D.20131>; else goto <D.20132>;
  <D.20131>:
  D.20133 = sgen_los_object_is_pinned (start);
  if (D.20133 == 0) goto <D.20134>; else goto <D.20135>;
  <D.20134>:
  return;
  <D.20135>:
  goto <D.20136>;
  <D.20132>:
  D.20137 = major_collector.is_object_live;
  D.20138 = D.20137 (start);
  if (D.20138 == 0) goto <D.20139>; else goto <D.20140>;
  <D.20139>:
  return;
  <D.20140>:
  <D.20136>:
  {
    struct GCVTable * vt;
    mword desc;

    D.20141 = MEM[(mword *)start];
    D.20142 = D.20141 & 18446744073709551612;
    vt = (struct GCVTable *) D.20142;
    desc = vt->desc;
    D.20143 = desc & 7;
    switch (D.20143) <default: <D.18526>, case 1: <D.18431>, case 2: <D.18440>, case 3: <D.18490>, case 4: <D.18450>, case 5: <D.18483>, case 6: <D.18504>, case 7: <D.18525>>
    <D.18431>:
    D.20144 = desc & 4294901760;
    if (D.20144 != 0) goto <D.20145>; else goto <D.20146>;
    <D.20145>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.20147 = desc >> 16;
      D.20148 = D.20147 & 255;
      D.20149 = D.20148 * 8;
      _objptr = _objptr + D.20149;
      D.20150 = desc >> 24;
      D.20151 = D.20150 & 255;
      D.20152 = D.20151 * 8;
      _objptr_end = _objptr + D.20152;
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.20153>; else goto <D.20154>;
        <D.20153>:
        D.20155 = is_valid_object_pointer (__target);
        D.20156 = D.20155 == 0;
        D.20157 = (long int) D.20156;
        D.20158 = __builtin_expect (D.20157, 0);
        if (D.20158 != 0) goto <D.20159>; else goto <D.20160>;
        <D.20159>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "is_valid_object_pointer (__target)");
        <D.20160>:
        D.20161 = sgen_ptr_in_nursery (__target);
        if (D.20161 != 0) goto <D.20162>; else goto <D.20163>;
        <D.20162>:
        D.20164 = MEM[(mword *)__target];
        D.20165 = D.20164 & 2;
        D.20166 = D.20165 == 0;
        D.20167 = (long int) D.20166;
        D.20168 = __builtin_expect (D.20167, 0);
        if (D.20168 != 0) goto <D.20169>; else goto <D.20170>;
        <D.20169>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.20170>:
        goto <D.20171>;
        <D.20163>:
        D.20172 = sgen_los_is_valid_object (__target);
        if (D.20172 != 0) goto <D.20173>; else goto <D.20174>;
        <D.20173>:
        D.20175 = sgen_los_object_is_pinned (__target);
        D.20176 = D.20175 == 0;
        D.20177 = (long int) D.20176;
        D.20178 = __builtin_expect (D.20177, 0);
        if (D.20178 != 0) goto <D.20179>; else goto <D.20180>;
        <D.20179>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_los_object_is_pinned (__target)");
        <D.20180>:
        goto <D.20181>;
        <D.20174>:
        D.20182 = major_collector.is_valid_object;
        D.20183 = D.20182 (__target);
        if (D.20183 != 0) goto <D.20184>; else goto <D.20185>;
        <D.20184>:
        D.20137 = major_collector.is_object_live;
        D.20186 = D.20137 (__target);
        D.20187 = D.20186 == 0;
        D.20188 = (long int) D.20187;
        D.20189 = __builtin_expect (D.20188, 0);
        if (D.20189 != 0) goto <D.20190>; else goto <D.20191>;
        <D.20190>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "major_collector.is_object_live (__target)");
        <D.20191>:
        goto <D.20192>;
        <D.20185>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 64);
        <D.20192>:
        <D.20181>:
        <D.20171>:
        <D.20154>:
      }
      _objptr = _objptr + 8;
      goto <D.18437>;
      <D.18436>:
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.20193>; else goto <D.20194>;
        <D.20193>:
        D.20195 = is_valid_object_pointer (__target);
        D.20196 = D.20195 == 0;
        D.20197 = (long int) D.20196;
        D.20198 = __builtin_expect (D.20197, 0);
        if (D.20198 != 0) goto <D.20199>; else goto <D.20200>;
        <D.20199>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "is_valid_object_pointer (__target)");
        <D.20200>:
        D.20201 = sgen_ptr_in_nursery (__target);
        if (D.20201 != 0) goto <D.20202>; else goto <D.20203>;
        <D.20202>:
        D.20204 = MEM[(mword *)__target];
        D.20205 = D.20204 & 2;
        D.20206 = D.20205 == 0;
        D.20207 = (long int) D.20206;
        D.20208 = __builtin_expect (D.20207, 0);
        if (D.20208 != 0) goto <D.20209>; else goto <D.20210>;
        <D.20209>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.20210>:
        goto <D.20211>;
        <D.20203>:
        D.20212 = sgen_los_is_valid_object (__target);
        if (D.20212 != 0) goto <D.20213>; else goto <D.20214>;
        <D.20213>:
        D.20215 = sgen_los_object_is_pinned (__target);
        D.20216 = D.20215 == 0;
        D.20217 = (long int) D.20216;
        D.20218 = __builtin_expect (D.20217, 0);
        if (D.20218 != 0) goto <D.20219>; else goto <D.20220>;
        <D.20219>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_los_object_is_pinned (__target)");
        <D.20220>:
        goto <D.20221>;
        <D.20214>:
        D.20182 = major_collector.is_valid_object;
        D.20222 = D.20182 (__target);
        if (D.20222 != 0) goto <D.20223>; else goto <D.20224>;
        <D.20223>:
        D.20137 = major_collector.is_object_live;
        D.20225 = D.20137 (__target);
        D.20226 = D.20225 == 0;
        D.20227 = (long int) D.20226;
        D.20228 = __builtin_expect (D.20227, 0);
        if (D.20228 != 0) goto <D.20229>; else goto <D.20230>;
        <D.20229>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "major_collector.is_object_live (__target)");
        <D.20230>:
        goto <D.20231>;
        <D.20224>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 64);
        <D.20231>:
        <D.20221>:
        <D.20211>:
        <D.20194>:
      }
      _objptr = _objptr + 8;
      <D.18437>:
      if (_objptr < _objptr_end) goto <D.18436>; else goto <D.18438>;
      <D.18438>:
    }
    <D.20146>:
    goto <D.18439>;
    <D.18440>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctzl (_bmap);
        D.20232 = (long unsigned int) _index;
        D.20233 = D.20232 * 8;
        _objptr = _objptr + D.20233;
        D.20234 = _index + 1;
        _bmap = _bmap >> D.20234;
        {
          char * __target;

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.20235>; else goto <D.20236>;
          <D.20235>:
          D.20237 = is_valid_object_pointer (__target);
          D.20238 = D.20237 == 0;
          D.20239 = (long int) D.20238;
          D.20240 = __builtin_expect (D.20239, 0);
          if (D.20240 != 0) goto <D.20241>; else goto <D.20242>;
          <D.20241>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "is_valid_object_pointer (__target)");
          <D.20242>:
          D.20243 = sgen_ptr_in_nursery (__target);
          if (D.20243 != 0) goto <D.20244>; else goto <D.20245>;
          <D.20244>:
          D.20246 = MEM[(mword *)__target];
          D.20247 = D.20246 & 2;
          D.20248 = D.20247 == 0;
          D.20249 = (long int) D.20248;
          D.20250 = __builtin_expect (D.20249, 0);
          if (D.20250 != 0) goto <D.20251>; else goto <D.20252>;
          <D.20251>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.20252>:
          goto <D.20253>;
          <D.20245>:
          D.20254 = sgen_los_is_valid_object (__target);
          if (D.20254 != 0) goto <D.20255>; else goto <D.20256>;
          <D.20255>:
          D.20257 = sgen_los_object_is_pinned (__target);
          D.20258 = D.20257 == 0;
          D.20259 = (long int) D.20258;
          D.20260 = __builtin_expect (D.20259, 0);
          if (D.20260 != 0) goto <D.20261>; else goto <D.20262>;
          <D.20261>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_los_object_is_pinned (__target)");
          <D.20262>:
          goto <D.20263>;
          <D.20256>:
          D.20182 = major_collector.is_valid_object;
          D.20264 = D.20182 (__target);
          if (D.20264 != 0) goto <D.20265>; else goto <D.20266>;
          <D.20265>:
          D.20137 = major_collector.is_object_live;
          D.20267 = D.20137 (__target);
          D.20268 = D.20267 == 0;
          D.20269 = (long int) D.20268;
          D.20270 = __builtin_expect (D.20269, 0);
          if (D.20270 != 0) goto <D.20271>; else goto <D.20272>;
          <D.20271>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "major_collector.is_object_live (__target)");
          <D.20272>:
          goto <D.20273>;
          <D.20266>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 71);
          <D.20273>:
          <D.20263>:
          <D.20253>:
          <D.20236>:
        }
        _objptr = _objptr + 8;
      }
      goto <D.18448>;
      <D.18447>:
      {
        int _index;

        _index = __builtin_ctzl (_bmap);
        D.20274 = (long unsigned int) _index;
        D.20275 = D.20274 * 8;
        _objptr = _objptr + D.20275;
        D.20276 = _index + 1;
        _bmap = _bmap >> D.20276;
        {
          char * __target;

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.20277>; else goto <D.20278>;
          <D.20277>:
          D.20279 = is_valid_object_pointer (__target);
          D.20280 = D.20279 == 0;
          D.20281 = (long int) D.20280;
          D.20282 = __builtin_expect (D.20281, 0);
          if (D.20282 != 0) goto <D.20283>; else goto <D.20284>;
          <D.20283>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "is_valid_object_pointer (__target)");
          <D.20284>:
          D.20285 = sgen_ptr_in_nursery (__target);
          if (D.20285 != 0) goto <D.20286>; else goto <D.20287>;
          <D.20286>:
          D.20288 = MEM[(mword *)__target];
          D.20289 = D.20288 & 2;
          D.20290 = D.20289 == 0;
          D.20291 = (long int) D.20290;
          D.20292 = __builtin_expect (D.20291, 0);
          if (D.20292 != 0) goto <D.20293>; else goto <D.20294>;
          <D.20293>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.20294>:
          goto <D.20295>;
          <D.20287>:
          D.20296 = sgen_los_is_valid_object (__target);
          if (D.20296 != 0) goto <D.20297>; else goto <D.20298>;
          <D.20297>:
          D.20299 = sgen_los_object_is_pinned (__target);
          D.20300 = D.20299 == 0;
          D.20301 = (long int) D.20300;
          D.20302 = __builtin_expect (D.20301, 0);
          if (D.20302 != 0) goto <D.20303>; else goto <D.20304>;
          <D.20303>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_los_object_is_pinned (__target)");
          <D.20304>:
          goto <D.20305>;
          <D.20298>:
          D.20182 = major_collector.is_valid_object;
          D.20306 = D.20182 (__target);
          if (D.20306 != 0) goto <D.20307>; else goto <D.20308>;
          <D.20307>:
          D.20137 = major_collector.is_object_live;
          D.20309 = D.20137 (__target);
          D.20310 = D.20309 == 0;
          D.20311 = (long int) D.20310;
          D.20312 = __builtin_expect (D.20311, 0);
          if (D.20312 != 0) goto <D.20313>; else goto <D.20314>;
          <D.20313>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "major_collector.is_object_live (__target)");
          <D.20314>:
          goto <D.20315>;
          <D.20308>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 71);
          <D.20315>:
          <D.20305>:
          <D.20295>:
          <D.20278>:
        }
        _objptr = _objptr + 8;
      }
      <D.18448>:
      if (_bmap != 0) goto <D.18447>; else goto <D.18449>;
      <D.18449>:
    }
    goto <D.18439>;
    <D.18450>:
    D.20316 = desc & 4294950912;
    if (D.20316 != 0) goto <D.20317>; else goto <D.20318>;
    <D.20317>:
    {
      int el_size;
      int etype;

      D.20319 = desc >> 3;
      D.20320 = (int) D.20319;
      el_size = D.20320 & 1023;
      D.20321 = (int) desc;
      etype = D.20321 & 49152;
      if (etype == 16384) goto <D.20322>; else goto <D.20323>;
      <D.20322>:
      {
        void * * p;
        void * * end_refs;

        p = start + 32;
        D.20324 = MEM[(struct MonoArray *)start].max_length;
        el_size.105 = (unsigned int) el_size;
        D.20326 = D.20324 * el_size.105;
        D.20327 = (sizetype) D.20326;
        end_refs = p + D.20327;
        goto <D.18457>;
        <D.18456>:
        {
          char * __target;

          __target = MEM[(char * *)p];
          if (__target != 0B) goto <D.20328>; else goto <D.20329>;
          <D.20328>:
          D.20330 = is_valid_object_pointer (__target);
          D.20331 = D.20330 == 0;
          D.20332 = (long int) D.20331;
          D.20333 = __builtin_expect (D.20332, 0);
          if (D.20333 != 0) goto <D.20334>; else goto <D.20335>;
          <D.20334>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "is_valid_object_pointer (__target)");
          <D.20335>:
          D.20336 = sgen_ptr_in_nursery (__target);
          if (D.20336 != 0) goto <D.20337>; else goto <D.20338>;
          <D.20337>:
          D.20339 = MEM[(mword *)__target];
          D.20340 = D.20339 & 2;
          D.20341 = D.20340 == 0;
          D.20342 = (long int) D.20341;
          D.20343 = __builtin_expect (D.20342, 0);
          if (D.20343 != 0) goto <D.20344>; else goto <D.20345>;
          <D.20344>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.20345>:
          goto <D.20346>;
          <D.20338>:
          D.20347 = sgen_los_is_valid_object (__target);
          if (D.20347 != 0) goto <D.20348>; else goto <D.20349>;
          <D.20348>:
          D.20350 = sgen_los_object_is_pinned (__target);
          D.20351 = D.20350 == 0;
          D.20352 = (long int) D.20351;
          D.20353 = __builtin_expect (D.20352, 0);
          if (D.20353 != 0) goto <D.20354>; else goto <D.20355>;
          <D.20354>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
          <D.20355>:
          goto <D.20356>;
          <D.20349>:
          D.20182 = major_collector.is_valid_object;
          D.20357 = D.20182 (__target);
          if (D.20357 != 0) goto <D.20358>; else goto <D.20359>;
          <D.20358>:
          D.20137 = major_collector.is_object_live;
          D.20360 = D.20137 (__target);
          D.20361 = D.20360 == 0;
          D.20362 = (long int) D.20361;
          D.20363 = __builtin_expect (D.20362, 0);
          if (D.20363 != 0) goto <D.20364>; else goto <D.20365>;
          <D.20364>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
          <D.20365>:
          goto <D.20366>;
          <D.20359>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
          <D.20366>:
          <D.20356>:
          <D.20346>:
          <D.20329>:
        }
        p = p + 8;
        <D.18457>:
        if (p < end_refs) goto <D.18456>; else goto <D.18458>;
        <D.18458>:
      }
      goto <D.20367>;
      <D.20323>:
      if (etype == 32768) goto <D.20368>; else goto <D.20369>;
      <D.20368>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.20147 = desc >> 16;
        D.20370 = (int) D.20147;
        offset = D.20370 & 255;
        D.20150 = desc >> 24;
        D.20371 = (int) D.20150;
        num_refs = D.20371 & 255;
        e_start = start + 32;
        D.20324 = MEM[(struct MonoArray *)start].max_length;
        el_size.105 = (unsigned int) el_size;
        D.20326 = D.20324 * el_size.105;
        D.20327 = (sizetype) D.20326;
        e_end = e_start + D.20327;
        goto <D.18470>;
        <D.18469>:
        {
          void * * p;
          int i;

          p = e_start;
          D.20372 = (long unsigned int) offset;
          D.20373 = D.20372 * 8;
          p = p + D.20373;
          i = 0;
          goto <D.18467>;
          <D.18466>:
          {
            char * __target;

            D.20374 = MEM[(char * *)p];
            D.20375 = (sizetype) i;
            __target = D.20374 + D.20375;
            if (__target != 0B) goto <D.20376>; else goto <D.20377>;
            <D.20376>:
            D.20378 = is_valid_object_pointer (__target);
            D.20379 = D.20378 == 0;
            D.20380 = (long int) D.20379;
            D.20381 = __builtin_expect (D.20380, 0);
            if (D.20381 != 0) goto <D.20382>; else goto <D.20383>;
            <D.20382>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "is_valid_object_pointer (__target)");
            <D.20383>:
            D.20384 = sgen_ptr_in_nursery (__target);
            if (D.20384 != 0) goto <D.20385>; else goto <D.20386>;
            <D.20385>:
            D.20387 = MEM[(mword *)__target];
            D.20388 = D.20387 & 2;
            D.20389 = D.20388 == 0;
            D.20390 = (long int) D.20389;
            D.20391 = __builtin_expect (D.20390, 0);
            if (D.20391 != 0) goto <D.20392>; else goto <D.20393>;
            <D.20392>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.20393>:
            goto <D.20394>;
            <D.20386>:
            D.20395 = sgen_los_is_valid_object (__target);
            if (D.20395 != 0) goto <D.20396>; else goto <D.20397>;
            <D.20396>:
            D.20398 = sgen_los_object_is_pinned (__target);
            D.20399 = D.20398 == 0;
            D.20400 = (long int) D.20399;
            D.20401 = __builtin_expect (D.20400, 0);
            if (D.20401 != 0) goto <D.20402>; else goto <D.20403>;
            <D.20402>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
            <D.20403>:
            goto <D.20404>;
            <D.20397>:
            D.20182 = major_collector.is_valid_object;
            D.20405 = D.20182 (__target);
            if (D.20405 != 0) goto <D.20406>; else goto <D.20407>;
            <D.20406>:
            D.20137 = major_collector.is_object_live;
            D.20408 = D.20137 (__target);
            D.20409 = D.20408 == 0;
            D.20410 = (long int) D.20409;
            D.20411 = __builtin_expect (D.20410, 0);
            if (D.20411 != 0) goto <D.20412>; else goto <D.20413>;
            <D.20412>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
            <D.20413>:
            goto <D.20414>;
            <D.20407>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
            <D.20414>:
            <D.20404>:
            <D.20394>:
            <D.20377>:
          }
          i = i + 1;
          <D.18467>:
          if (i < num_refs) goto <D.18466>; else goto <D.18468>;
          <D.18468>:
          D.20415 = (sizetype) el_size;
          e_start = e_start + D.20415;
        }
        <D.18470>:
        if (e_start < e_end) goto <D.18469>; else goto <D.18471>;
        <D.18471>:
      }
      goto <D.20416>;
      <D.20369>:
      if (etype == 49152) goto <D.20417>; else goto <D.20418>;
      <D.20417>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 32;
        D.20324 = MEM[(struct MonoArray *)start].max_length;
        el_size.105 = (unsigned int) el_size;
        D.20326 = D.20324 * el_size.105;
        D.20327 = (sizetype) D.20326;
        e_end = e_start + D.20327;
        goto <D.18481>;
        <D.18480>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.18478>;
          <D.18477>:
          D.20419 = _bmap & 1;
          if (D.20419 != 0) goto <D.20420>; else goto <D.20421>;
          <D.20420>:
          {
            char * __target;

            __target = MEM[(char * *)p];
            if (__target != 0B) goto <D.20422>; else goto <D.20423>;
            <D.20422>:
            D.20424 = is_valid_object_pointer (__target);
            D.20425 = D.20424 == 0;
            D.20426 = (long int) D.20425;
            D.20427 = __builtin_expect (D.20426, 0);
            if (D.20427 != 0) goto <D.20428>; else goto <D.20429>;
            <D.20428>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "is_valid_object_pointer (__target)");
            <D.20429>:
            D.20430 = sgen_ptr_in_nursery (__target);
            if (D.20430 != 0) goto <D.20431>; else goto <D.20432>;
            <D.20431>:
            D.20433 = MEM[(mword *)__target];
            D.20434 = D.20433 & 2;
            D.20435 = D.20434 == 0;
            D.20436 = (long int) D.20435;
            D.20437 = __builtin_expect (D.20436, 0);
            if (D.20437 != 0) goto <D.20438>; else goto <D.20439>;
            <D.20438>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.20439>:
            goto <D.20440>;
            <D.20432>:
            D.20441 = sgen_los_is_valid_object (__target);
            if (D.20441 != 0) goto <D.20442>; else goto <D.20443>;
            <D.20442>:
            D.20444 = sgen_los_object_is_pinned (__target);
            D.20445 = D.20444 == 0;
            D.20446 = (long int) D.20445;
            D.20447 = __builtin_expect (D.20446, 0);
            if (D.20447 != 0) goto <D.20448>; else goto <D.20449>;
            <D.20448>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
            <D.20449>:
            goto <D.20450>;
            <D.20443>:
            D.20182 = major_collector.is_valid_object;
            D.20451 = D.20182 (__target);
            if (D.20451 != 0) goto <D.20452>; else goto <D.20453>;
            <D.20452>:
            D.20137 = major_collector.is_object_live;
            D.20454 = D.20137 (__target);
            D.20455 = D.20454 == 0;
            D.20456 = (long int) D.20455;
            D.20457 = __builtin_expect (D.20456, 0);
            if (D.20457 != 0) goto <D.20458>; else goto <D.20459>;
            <D.20458>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
            <D.20459>:
            goto <D.20460>;
            <D.20453>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
            <D.20460>:
            <D.20450>:
            <D.20440>:
            <D.20423>:
          }
          <D.20421>:
          _bmap = _bmap >> 1;
          p = p + 8;
          <D.18478>:
          if (_bmap != 0) goto <D.18477>; else goto <D.18479>;
          <D.18479>:
          D.20415 = (sizetype) el_size;
          e_start = e_start + D.20415;
        }
        <D.18481>:
        if (e_start < e_end) goto <D.18480>; else goto <D.18482>;
        <D.18482>:
      }
      <D.20418>:
      <D.20416>:
      <D.20367>:
    }
    <D.20318>:
    goto <D.18439>;
    <D.18483>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 16;
      goto <D.18488>;
      <D.18487>:
      D.20461 = _bmap & 1;
      if (D.20461 != 0) goto <D.20462>; else goto <D.20463>;
      <D.20462>:
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.20464>; else goto <D.20465>;
        <D.20464>:
        D.20466 = is_valid_object_pointer (__target);
        D.20467 = D.20466 == 0;
        D.20468 = (long int) D.20467;
        D.20469 = __builtin_expect (D.20468, 0);
        if (D.20469 != 0) goto <D.20470>; else goto <D.20471>;
        <D.20470>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "is_valid_object_pointer (__target)");
        <D.20471>:
        D.20472 = sgen_ptr_in_nursery (__target);
        if (D.20472 != 0) goto <D.20473>; else goto <D.20474>;
        <D.20473>:
        D.20475 = MEM[(mword *)__target];
        D.20476 = D.20475 & 2;
        D.20477 = D.20476 == 0;
        D.20478 = (long int) D.20477;
        D.20479 = __builtin_expect (D.20478, 0);
        if (D.20479 != 0) goto <D.20480>; else goto <D.20481>;
        <D.20480>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.20481>:
        goto <D.20482>;
        <D.20474>:
        D.20483 = sgen_los_is_valid_object (__target);
        if (D.20483 != 0) goto <D.20484>; else goto <D.20485>;
        <D.20484>:
        D.20486 = sgen_los_object_is_pinned (__target);
        D.20487 = D.20486 == 0;
        D.20488 = (long int) D.20487;
        D.20489 = __builtin_expect (D.20488, 0);
        if (D.20489 != 0) goto <D.20490>; else goto <D.20491>;
        <D.20490>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "sgen_los_object_is_pinned (__target)");
        <D.20491>:
        goto <D.20492>;
        <D.20485>:
        D.20182 = major_collector.is_valid_object;
        D.20493 = D.20182 (__target);
        if (D.20493 != 0) goto <D.20494>; else goto <D.20495>;
        <D.20494>:
        D.20137 = major_collector.is_object_live;
        D.20496 = D.20137 (__target);
        D.20497 = D.20496 == 0;
        D.20498 = (long int) D.20497;
        D.20499 = __builtin_expect (D.20498, 0);
        if (D.20499 != 0) goto <D.20500>; else goto <D.20501>;
        <D.20500>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "major_collector.is_object_live (__target)");
        <D.20501>:
        goto <D.20502>;
        <D.20495>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 85);
        <D.20502>:
        <D.20492>:
        <D.20482>:
        <D.20465>:
      }
      <D.20463>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 8;
      <D.18488>:
      if (_bmap != 0) goto <D.18487>; else goto <D.18489>;
      <D.18489>:
    }
    goto <D.18439>;
    <D.18490>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.20503 = *bitmap_data;
      D.20504 = (unsigned int) D.20503;
      D.20505 = D.20504 + 4294967295;
      bwords = (int) D.20505;
      start_run = _objptr;
      bitmap_data = bitmap_data + 8;
      if (0 != 0) goto <D.20506>; else goto <D.20507>;
      <D.20506>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.20508 = myobj->vtable;
        D.20509 = D.20508->klass;
        D.20510 = D.20509->name_space;
        D.20508 = myobj->vtable;
        D.20509 = D.20508->klass;
        D.20511 = D.20509->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.20510, D.20511);
      }
      <D.20507>:
      goto <D.18502>;
      <D.18501>:
      {
        gsize _bmap;

        bitmap_data.106 = bitmap_data;
        bitmap_data = bitmap_data.106 + 8;
        _bmap = *bitmap_data.106;
        _objptr = start_run;
        goto <D.18499>;
        <D.18498>:
        D.20513 = _bmap & 1;
        if (D.20513 != 0) goto <D.20514>; else goto <D.20515>;
        <D.20514>:
        {
          char * __target;

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.20516>; else goto <D.20517>;
          <D.20516>:
          D.20518 = is_valid_object_pointer (__target);
          D.20519 = D.20518 == 0;
          D.20520 = (long int) D.20519;
          D.20521 = __builtin_expect (D.20520, 0);
          if (D.20521 != 0) goto <D.20522>; else goto <D.20523>;
          <D.20522>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "is_valid_object_pointer (__target)");
          <D.20523>:
          D.20524 = sgen_ptr_in_nursery (__target);
          if (D.20524 != 0) goto <D.20525>; else goto <D.20526>;
          <D.20525>:
          D.20527 = MEM[(mword *)__target];
          D.20528 = D.20527 & 2;
          D.20529 = D.20528 == 0;
          D.20530 = (long int) D.20529;
          D.20531 = __builtin_expect (D.20530, 0);
          if (D.20531 != 0) goto <D.20532>; else goto <D.20533>;
          <D.20532>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.20533>:
          goto <D.20534>;
          <D.20526>:
          D.20535 = sgen_los_is_valid_object (__target);
          if (D.20535 != 0) goto <D.20536>; else goto <D.20537>;
          <D.20536>:
          D.20538 = sgen_los_object_is_pinned (__target);
          D.20539 = D.20538 == 0;
          D.20540 = (long int) D.20539;
          D.20541 = __builtin_expect (D.20540, 0);
          if (D.20541 != 0) goto <D.20542>; else goto <D.20543>;
          <D.20542>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "sgen_los_object_is_pinned (__target)");
          <D.20543>:
          goto <D.20544>;
          <D.20537>:
          D.20182 = major_collector.is_valid_object;
          D.20545 = D.20182 (__target);
          if (D.20545 != 0) goto <D.20546>; else goto <D.20547>;
          <D.20546>:
          D.20137 = major_collector.is_object_live;
          D.20548 = D.20137 (__target);
          D.20549 = D.20548 == 0;
          D.20550 = (long int) D.20549;
          D.20551 = __builtin_expect (D.20550, 0);
          if (D.20551 != 0) goto <D.20552>; else goto <D.20553>;
          <D.20552>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "major_collector.is_object_live (__target)");
          <D.20553>:
          goto <D.20554>;
          <D.20547>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 93);
          <D.20554>:
          <D.20544>:
          <D.20534>:
          <D.20517>:
        }
        <D.20515>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18499>:
        if (_bmap != 0) goto <D.18498>; else goto <D.18500>;
        <D.18500>:
        start_run = start_run + 512;
      }
      <D.18502>:
      bwords.107 = bwords;
      bwords = bwords.107 + -1;
      if (bwords.107 > 0) goto <D.18501>; else goto <D.18503>;
      <D.18503>:
    }
    goto <D.18439>;
    <D.18504>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.20556 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.20556);
      mbitmap_data.108 = mbitmap_data;
      mbitmap_data = mbitmap_data.108 + 8;
      D.20558 = *mbitmap_data.108;
      D.20559 = (unsigned int) D.20558;
      D.20560 = D.20559 + 4294967295;
      mbwords = (int) D.20560;
      D.20561 = vt->klass;
      el_size = mono_array_element_size (D.20561);
      e_start = start + 32;
      D.20324 = MEM[(struct MonoArray *)start].max_length;
      el_size.109 = (unsigned int) el_size;
      D.20563 = D.20324 * el_size.109;
      D.20564 = (sizetype) D.20563;
      e_end = e_start + D.20564;
      if (0 != 0) goto <D.20565>; else goto <D.20566>;
      <D.20565>:
      D.20556 = vt->desc;
      D.20561 = vt->klass;
      D.20567 = D.20561->name_space;
      D.20561 = vt->klass;
      D.20568 = D.20561->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.20556, D.20567, D.20568);
      <D.20566>:
      goto <D.18523>;
      <D.18522>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.110 = bitmap_data;
          bitmap_data = bitmap_data.110 + 8;
          _bmap = *bitmap_data.110;
          start_run = _objptr;
          goto <D.18517>;
          <D.18516>:
          D.20570 = _bmap & 1;
          if (D.20570 != 0) goto <D.20571>; else goto <D.20572>;
          <D.20571>:
          {
            char * __target;

            __target = MEM[(char * *)_objptr];
            if (__target != 0B) goto <D.20573>; else goto <D.20574>;
            <D.20573>:
            D.20575 = is_valid_object_pointer (__target);
            D.20576 = D.20575 == 0;
            D.20577 = (long int) D.20576;
            D.20578 = __builtin_expect (D.20577, 0);
            if (D.20578 != 0) goto <D.20579>; else goto <D.20580>;
            <D.20579>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "is_valid_object_pointer (__target)");
            <D.20580>:
            D.20581 = sgen_ptr_in_nursery (__target);
            if (D.20581 != 0) goto <D.20582>; else goto <D.20583>;
            <D.20582>:
            D.20584 = MEM[(mword *)__target];
            D.20585 = D.20584 & 2;
            D.20586 = D.20585 == 0;
            D.20587 = (long int) D.20586;
            D.20588 = __builtin_expect (D.20587, 0);
            if (D.20588 != 0) goto <D.20589>; else goto <D.20590>;
            <D.20589>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.20590>:
            goto <D.20591>;
            <D.20583>:
            D.20592 = sgen_los_is_valid_object (__target);
            if (D.20592 != 0) goto <D.20593>; else goto <D.20594>;
            <D.20593>:
            D.20595 = sgen_los_object_is_pinned (__target);
            D.20596 = D.20595 == 0;
            D.20597 = (long int) D.20596;
            D.20598 = __builtin_expect (D.20597, 0);
            if (D.20598 != 0) goto <D.20599>; else goto <D.20600>;
            <D.20599>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "sgen_los_object_is_pinned (__target)");
            <D.20600>:
            goto <D.20601>;
            <D.20594>:
            D.20182 = major_collector.is_valid_object;
            D.20602 = D.20182 (__target);
            if (D.20602 != 0) goto <D.20603>; else goto <D.20604>;
            <D.20603>:
            D.20137 = major_collector.is_object_live;
            D.20605 = D.20137 (__target);
            D.20606 = D.20605 == 0;
            D.20607 = (long int) D.20606;
            D.20608 = __builtin_expect (D.20607, 0);
            if (D.20608 != 0) goto <D.20609>; else goto <D.20610>;
            <D.20609>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "major_collector.is_object_live (__target)");
            <D.20610>:
            goto <D.20611>;
            <D.20604>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 102);
            <D.20611>:
            <D.20601>:
            <D.20591>:
            <D.20574>:
          }
          <D.20572>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18517>:
          if (_bmap != 0) goto <D.18516>; else goto <D.18518>;
          <D.18518>:
          _objptr = start_run + 512;
        }
        <D.18520>:
        bwords.111 = bwords;
        bwords = bwords.111 + 4294967295;
        if (bwords.111 != 0) goto <D.18519>; else goto <D.18521>;
        <D.18521>:
        D.20613 = (sizetype) el_size;
        e_start = e_start + D.20613;
      }
      <D.18523>:
      if (e_start < e_end) goto <D.18522>; else goto <D.18524>;
      <D.18524>:
    }
    goto <D.18439>;
    <D.18525>:
    goto <D.18439>;
    <D.18526>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.18439>:
  }
}


__attribute__((visibility ("hidden")))
sgen_check_nursery_objects_pinned (gboolean pinned)
{
  struct GCMemSection * nursery_section.112;
  char * D.20617;
  char * D.20618;
  long unsigned int D.20619;
  void * D.20620;

  sgen_clear_nursery_fragments ();
  nursery_section.112 = nursery_section;
  D.20617 = nursery_section.112->data;
  nursery_section.112 = nursery_section;
  D.20618 = nursery_section.112->end_data;
  D.20619 = (long unsigned int) pinned;
  D.20620 = (void *) D.20619;
  sgen_scan_area_with_callback (D.20617, D.20618, check_nursery_objects_pinned_callback, D.20620, 0);
}


check_nursery_objects_pinned_callback (char * obj, size_t size, void * data)
{
  long int data.113;
  int iftmp.114;
  long unsigned int D.20625;
  long unsigned int D.20626;
  long unsigned int D.20628;
  _Bool D.20630;
  long int D.20631;
  long int D.20632;
  long unsigned int D.20637;
  _Bool D.20638;
  long int D.20639;
  long int D.20640;
  _Bool D.20644;
  long int D.20645;
  long int D.20646;
  gboolean pinned;

  data.113 = (long int) data;
  pinned = (gboolean) data.113;
  D.20625 = MEM[(mword *)obj];
  D.20626 = D.20625 & 1;
  if (D.20626 != 0) goto <D.20627>; else goto <D.20623>;
  <D.20627>:
  D.20625 = MEM[(mword *)obj];
  D.20628 = D.20625 & 18446744073709551612;
  if (D.20628 != 0) goto <D.20629>; else goto <D.20623>;
  <D.20629>:
  iftmp.114 = 1;
  goto <D.20624>;
  <D.20623>:
  iftmp.114 = 0;
  <D.20624>:
  D.20630 = iftmp.114 != 0;
  D.20631 = (long int) D.20630;
  D.20632 = __builtin_expect (D.20631, 0);
  if (D.20632 != 0) goto <D.20633>; else goto <D.20634>;
  <D.20633>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 575, "!SGEN_OBJECT_IS_FORWARDED (obj)");
  <D.20634>:
  if (pinned != 0) goto <D.20635>; else goto <D.20636>;
  <D.20635>:
  D.20625 = MEM[(mword *)obj];
  D.20637 = D.20625 & 2;
  D.20638 = D.20637 == 0;
  D.20639 = (long int) D.20638;
  D.20640 = __builtin_expect (D.20639, 0);
  if (D.20640 != 0) goto <D.20641>; else goto <D.20642>;
  <D.20641>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 577, "SGEN_OBJECT_IS_PINNED (obj)");
  <D.20642>:
  goto <D.20643>;
  <D.20636>:
  D.20625 = MEM[(mword *)obj];
  D.20637 = D.20625 & 2;
  D.20644 = D.20637 != 0;
  D.20645 = (long int) D.20644;
  D.20646 = __builtin_expect (D.20645, 0);
  if (D.20646 != 0) goto <D.20647>; else goto <D.20648>;
  <D.20647>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 579, "!SGEN_OBJECT_IS_PINNED (obj)");
  <D.20648>:
  <D.20643>:
}