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


describe_pointer (char * ptr, gboolean need_setup)
{
  int D.20596;
  char * start.0;
  char * start.1;
  unsigned int D.20603;
  unsigned int D.20604;
  int D.20606;
  int ptr.2;
  int start.3;
  int D.20614;
  gboolean (*<T36d4>) (char *, char * *) D.20616;
  int D.20617;
  struct MonoVTable * (*<T36ee>) (char *) D.20628;
  gboolean (*<T3655>) (char *) D.20630;
  int D.20631;
  unsigned int D.20635;
  char * iftmp.4;
  unsigned int D.20639;
  int D.20647;
  struct MonoClass * D.20650;
  const char * D.20651;
  long int desc.5;
  int desc.6;
  const char * D.20654;
  int size.7;
  struct MonoVTable * vtable;
  mword desc;
  int type;
  char * start;
  char * forwarded;
  mword size;
  void restart = <<< error >>>;
  void bridge = <<< error >>>;

  try
    {
      restart:
      D.20596 = sgen_ptr_in_nursery (ptr);
      if (D.20596 != 0) goto <D.20597>; else goto <D.20598>;
      <D.20597>:
      start.0 = describe_nursery_ptr (ptr, need_setup);
      start = start.0;
      start.1 = start;
      if (start.1 == 0B) goto <D.20601>; else goto <D.20602>;
      <D.20601>:
      return;
      <D.20602>:
      ptr = start;
      D.20603 = MEM[(mword *)ptr];
      D.20604 = D.20603 & 4294967292;
      vtable = (struct MonoVTable *) D.20604;
      goto <D.20605>;
      <D.20598>:
      D.20606 = sgen_ptr_is_in_los (ptr, &start);
      if (D.20606 != 0) goto <D.20607>; else goto <D.20608>;
      <D.20607>:
      start.1 = start;
      if (ptr == start.1) goto <D.20609>; else goto <D.20610>;
      <D.20609>:
      start.1 = start;
      printf ("Pointer is the start of object %p in LOS space.\n", start.1);
      goto <D.20611>;
      <D.20610>:
      ptr.2 = (int) ptr;
      start.1 = start;
      start.3 = (int) start.1;
      D.20614 = ptr.2 - start.3;
      start.1 = start;
      printf ("Pointer is at offset 0x%x of object %p in LOS space.\n", D.20614, start.1);
      <D.20611>:
      ptr = start;
      mono_sgen_los_describe_pointer (ptr);
      D.20603 = MEM[(mword *)ptr];
      D.20604 = D.20603 & 4294967292;
      vtable = (struct MonoVTable *) D.20604;
      goto <D.20615>;
      <D.20608>:
      D.20616 = major_collector.ptr_is_in_non_pinned_space;
      D.20617 = D.20616 (ptr, &start);
      if (D.20617 != 0) goto <D.20618>; else goto <D.20619>;
      <D.20618>:
      start.1 = start;
      if (ptr == start.1) goto <D.20620>; else goto <D.20621>;
      <D.20620>:
      start.1 = start;
      printf ("Pointer is the start of object %p in oldspace.\n", start.1);
      goto <D.20622>;
      <D.20621>:
      start.1 = start;
      if (start.1 != 0B) goto <D.20623>; else goto <D.20624>;
      <D.20623>:
      ptr.2 = (int) ptr;
      start.1 = start;
      start.3 = (int) start.1;
      D.20614 = ptr.2 - start.3;
      start.1 = start;
      printf ("Pointer is at offset 0x%x of object %p in oldspace.\n", D.20614, start.1);
      goto <D.20625>;
      <D.20624>:
      printf ("Pointer inside oldspace.\n");
      <D.20625>:
      <D.20622>:
      start.1 = start;
      if (start.1 != 0B) goto <D.20626>; else goto <D.20627>;
      <D.20626>:
      ptr = start;
      <D.20627>:
      D.20628 = major_collector.describe_pointer;
      vtable = D.20628 (ptr);
      goto <D.20629>;
      <D.20619>:
      D.20630 = major_collector.obj_is_from_pinned_alloc;
      D.20631 = D.20630 (ptr);
      if (D.20631 != 0) goto <D.20632>; else goto <D.20633>;
      <D.20632>:
      printf ("Pointer is inside a pinned chunk.\n");
      D.20603 = MEM[(mword *)ptr];
      D.20604 = D.20603 & 4294967292;
      vtable = (struct MonoVTable *) D.20604;
      goto <D.20634>;
      <D.20633>:
      printf ("Pointer unknown.\n");
      return;
      <D.20634>:
      <D.20629>:
      <D.20615>:
      <D.20605>:
      D.20603 = MEM[(mword *)ptr];
      D.20635 = D.20603 & 2;
      if (D.20635 != 0) goto <D.20636>; else goto <D.20637>;
      <D.20636>:
      printf ("Object is pinned.\n");
      <D.20637>:
      D.20603 = MEM[(mword *)ptr];
      D.20639 = D.20603 & 1;
      if (D.20639 != 0) goto <D.20640>; else goto <D.20641>;
      <D.20640>:
      D.20603 = MEM[(mword *)ptr];
      D.20604 = D.20603 & 4294967292;
      iftmp.4 = (char *) D.20604;
      goto <D.20642>;
      <D.20641>:
      iftmp.4 = 0B;
      <D.20642>:
      forwarded = iftmp.4;
      if (forwarded != 0B) goto <D.20643>; else goto <D.20644>;
      <D.20643>:
      printf ("Object is forwarded to %p:\n", forwarded);
      ptr = forwarded;
      goto restart;
      <D.20644>:
      printf ("VTable: %p\n", vtable);
      if (vtable == 0B) goto <D.20645>; else goto <D.20646>;
      <D.20645>:
      printf ("VTable is invalid (empty).\n");
      goto bridge;
      <D.20646>:
      D.20647 = sgen_ptr_in_nursery (vtable);
      if (D.20647 != 0) goto <D.20648>; else goto <D.20649>;
      <D.20648>:
      printf ("VTable is invalid (points inside nursery).\n");
      goto bridge;
      <D.20649>:
      D.20650 = vtable->klass;
      D.20651 = D.20650->name;
      printf ("Class: %s\n", D.20651);
      desc = MEM[(struct GCVTable *)vtable].desc;
      desc.5 = (long int) desc;
      printf ("Descriptor: %lx\n", desc.5);
      desc.6 = (int) desc;
      type = desc.6 & 7;
      D.20654 = descriptor_types[type];
      printf ("Descriptor type: %d (%s)\n", type, D.20654);
      size = sgen_safe_object_get_size (ptr);
      size.7 = (int) size;
      printf ("Size: %d\n", size.7);
      bridge:
      sgen_bridge_describe_pointer (ptr);
    }
  finally
    {
      start = {CLOBBER};
    }
}


describe_nursery_ptr (char * ptr, gboolean need_setup)
{
  char * * valid_nursery_objects.8;
  unsigned int i.9;
  unsigned int D.20663;
  char * * D.20664;
  char * D.20665;
  int valid_nursery_object_count.10;
  unsigned int D.20671;
  char * D.20672;
  int gc_debug_level.11;
  _Bool D.20674;
  long int D.20675;
  long int D.20676;
  struct FILE * gc_debug_file.12;
  char * D.20680;
  int ptr.13;
  int obj.14;
  int D.20690;
  int i;

  if (need_setup != 0) goto <D.20659>; else goto <D.20660>;
  <D.20659>:
  setup_valid_nursery_objects ();
  <D.20660>:
  i = 0;
  goto <D.20315>;
  <D.20314>:
  valid_nursery_objects.8 = valid_nursery_objects;
  i.9 = (unsigned int) i;
  D.20663 = i.9 * 4;
  D.20664 = valid_nursery_objects.8 + D.20663;
  D.20665 = *D.20664;
  if (D.20665 >= ptr) goto <D.20313>; else goto <D.20666>;
  <D.20666>:
  i = i + 1;
  <D.20315>:
  valid_nursery_object_count.10 = valid_nursery_object_count;
  if (i < valid_nursery_object_count.10) goto <D.20314>; else goto <D.20313>;
  <D.20313>:
  valid_nursery_object_count.10 = valid_nursery_object_count;
  if (i >= valid_nursery_object_count.10) goto <D.20668>; else goto <D.20670>;
  <D.20670>:
  valid_nursery_objects.8 = valid_nursery_objects;
  i.9 = (unsigned int) i;
  D.20663 = i.9 * 4;
  D.20664 = valid_nursery_objects.8 + D.20663;
  D.20665 = *D.20664;
  valid_nursery_objects.8 = valid_nursery_objects;
  i.9 = (unsigned int) i;
  D.20663 = i.9 * 4;
  D.20664 = valid_nursery_objects.8 + D.20663;
  D.20665 = *D.20664;
  D.20671 = sgen_safe_object_get_size (D.20665);
  D.20672 = D.20665 + D.20671;
  if (D.20672 < ptr) goto <D.20668>; else goto <D.20669>;
  <D.20668>:
  gc_debug_level.11 = gc_debug_level;
  D.20674 = gc_debug_level.11 >= 0;
  D.20675 = (long int) D.20674;
  D.20676 = __builtin_expect (D.20675, 0);
  if (D.20676 != 0) goto <D.20677>; else goto <D.20678>;
  <D.20677>:
  gc_debug_file.12 = gc_debug_file;
  fprintf (gc_debug_file.12, "nursery-ptr (unalloc\'d-memory)\n\n");
  gc_debug_file.12 = gc_debug_file;
  fflush (gc_debug_file.12);
  <D.20678>:
  D.20680 = 0B;
  return D.20680;
  <D.20669>:
  {
    char * obj;

    valid_nursery_objects.8 = valid_nursery_objects;
    i.9 = (unsigned int) i;
    D.20663 = i.9 * 4;
    D.20664 = valid_nursery_objects.8 + D.20663;
    obj = *D.20664;
    if (obj == ptr) goto <D.20681>; else goto <D.20682>;
    <D.20681>:
    gc_debug_level.11 = gc_debug_level;
    D.20674 = gc_debug_level.11 >= 0;
    D.20675 = (long int) D.20674;
    D.20676 = __builtin_expect (D.20675, 0);
    if (D.20676 != 0) goto <D.20683>; else goto <D.20684>;
    <D.20683>:
    gc_debug_file.12 = gc_debug_file;
    fprintf (gc_debug_file.12, "nursery-ptr\n\n");
    gc_debug_file.12 = gc_debug_file;
    fflush (gc_debug_file.12);
    <D.20684>:
    goto <D.20685>;
    <D.20682>:
    gc_debug_level.11 = gc_debug_level;
    D.20674 = gc_debug_level.11 >= 0;
    D.20675 = (long int) D.20674;
    D.20676 = __builtin_expect (D.20675, 0);
    if (D.20676 != 0) goto <D.20686>; else goto <D.20687>;
    <D.20686>:
    gc_debug_file.12 = gc_debug_file;
    ptr.13 = (int) ptr;
    obj.14 = (int) obj;
    D.20690 = ptr.13 - obj.14;
    fprintf (gc_debug_file.12, "nursery-ptr (interior-ptr offset %td)\n\n", D.20690);
    gc_debug_file.12 = gc_debug_file;
    fflush (gc_debug_file.12);
    <D.20687>:
    <D.20685>:
    D.20680 = obj;
    return D.20680;
  }
}


setup_valid_nursery_objects ()
{
  char * * valid_nursery_objects.15;
  int sgen_nursery_size.16;
  unsigned int sgen_nursery_size.17;
  void * valid_nursery_objects.18;
  struct GCMemSection * nursery_section.19;
  char * D.20699;
  char * D.20700;

  valid_nursery_objects.15 = valid_nursery_objects;
  if (valid_nursery_objects.15 == 0B) goto <D.20693>; else goto <D.20694>;
  <D.20693>:
  sgen_nursery_size.16 = sgen_nursery_size;
  sgen_nursery_size.17 = (unsigned int) sgen_nursery_size.16;
  valid_nursery_objects.18 = sgen_alloc_os_memory (sgen_nursery_size.17, 2, "debugging data");
  valid_nursery_objects = valid_nursery_objects.18;
  <D.20694>:
  valid_nursery_object_count = 0;
  nursery_section.19 = nursery_section;
  D.20699 = nursery_section.19->data;
  nursery_section.19 = nursery_section;
  D.20700 = nursery_section.19->end_data;
  sgen_scan_area_with_callback (D.20699, D.20700, 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.20;
  int valid_nursery_object_count.21;
  int valid_nursery_object_count.22;
  int valid_nursery_object_count.23;
  unsigned int valid_nursery_object_count.24;
  unsigned int D.20706;
  char * * D.20707;

  valid_nursery_objects.20 = valid_nursery_objects;
  valid_nursery_object_count.21 = valid_nursery_object_count;
  valid_nursery_object_count.22 = valid_nursery_object_count.21;
  valid_nursery_object_count.23 = valid_nursery_object_count.22 + 1;
  valid_nursery_object_count = valid_nursery_object_count.23;
  valid_nursery_object_count.24 = (unsigned int) valid_nursery_object_count.22;
  D.20706 = valid_nursery_object_count.24 * 4;
  D.20707 = valid_nursery_objects.20 + D.20706;
  *D.20707 = object;
}


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

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


sgen_ptr_in_nursery (void * p)
{
  gboolean D.20710;
  int sgen_nursery_bits.25;
  int D.20712;
  int D.20713;
  unsigned int D.20714;
  unsigned int p.26;
  unsigned int D.20716;
  char * sgen_nursery_start.27;
  unsigned int sgen_nursery_start.28;
  _Bool D.20719;

  sgen_nursery_bits.25 = sgen_nursery_bits;
  D.20712 = 1 << sgen_nursery_bits.25;
  D.20713 = -D.20712;
  D.20714 = (unsigned int) D.20713;
  p.26 = (unsigned int) p;
  D.20716 = D.20714 & p.26;
  sgen_nursery_start.27 = sgen_nursery_start;
  sgen_nursery_start.28 = (unsigned int) sgen_nursery_start.27;
  D.20719 = D.20716 == sgen_nursery_start.28;
  D.20710 = (gboolean) D.20719;
  return D.20710;
}


sgen_safe_object_get_size (struct MonoObject * obj)
{
  char * iftmp.29;
  unsigned int D.20722;
  unsigned int D.20723;
  unsigned int D.20726;
  guint D.20730;
  struct MonoVTable * D.20731;
  char * forwarded;

  D.20722 = MEM[(mword *)obj];
  D.20723 = D.20722 & 1;
  if (D.20723 != 0) goto <D.20724>; else goto <D.20725>;
  <D.20724>:
  D.20722 = MEM[(mword *)obj];
  D.20726 = D.20722 & 4294967292;
  iftmp.29 = (char *) D.20726;
  goto <D.20727>;
  <D.20725>:
  iftmp.29 = 0B;
  <D.20727>:
  forwarded = iftmp.29;
  if (forwarded != 0B) goto <D.20728>; else goto <D.20729>;
  <D.20728>:
  obj = forwarded;
  <D.20729>:
  D.20722 = MEM[(mword *)obj];
  D.20726 = D.20722 & 4294967292;
  D.20731 = (struct MonoVTable *) D.20726;
  D.20730 = sgen_par_object_get_size (D.20731, obj);
  return D.20730;
}


sgen_par_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  void * D.20733;
  unsigned int D.20734;
  guint D.20739;
  int D.20740;
  int D.20741;
  unsigned int D.20742;
  unsigned int D.20745;
  int D.20746;
  unsigned int D.20747;
  unsigned int element_size.30;
  unsigned int D.20749;
  unsigned int D.20750;
  struct MonoClass * D.20753;
  unsigned char D.20754;
  unsigned int D.20755;
  unsigned int D.20756;
  mword descr;
  mword type;

  D.20733 = vtable->gc_descr;
  descr = (mword) D.20733;
  type = descr & 7;
  D.20734 = type + 4294967295;
  if (D.20734 <= 1) goto <D.20735>; else goto <D.20736>;
  <D.20735>:
  {
    mword size;

    size = descr & 65528;
    if (size == 0) goto <D.20737>; else goto <D.20738>;
    <D.20737>:
    D.20740 = MEM[(struct MonoString *)o].length;
    D.20741 = D.20740 * 2;
    D.20742 = (unsigned int) D.20741;
    D.20739 = D.20742 + 14;
    return D.20739;
    <D.20738>:
    D.20739 = size;
    return D.20739;
  }
  <D.20736>:
  if (type == 4) goto <D.20743>; else goto <D.20744>;
  <D.20743>:
  {
    int element_size;
    struct MonoArray * array;
    size_t size;

    D.20745 = descr >> 3;
    D.20746 = (int) D.20745;
    element_size = D.20746 & 1023;
    array = o;
    D.20747 = array->max_length;
    element_size.30 = (unsigned int) element_size;
    D.20749 = D.20747 * element_size.30;
    size = D.20749 + 16;
    D.20750 = descr & 8192;
    if (D.20750 != 0) goto <D.20751>; else goto <D.20752>;
    <D.20751>:
    size = size + 3;
    size = size & 4294967292;
    D.20753 = vtable->klass;
    D.20754 = D.20753->rank;
    D.20755 = (unsigned int) D.20754;
    D.20756 = D.20755 * 8;
    size = D.20756 + size;
    <D.20752>:
    D.20739 = size;
    return D.20739;
  }
  <D.20744>:
  D.20739 = slow_object_get_size (vtable, o);
  return D.20739;
}


slow_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  struct MonoClass * D.20758;
  guint D.20761;
  int D.20762;
  int D.20763;
  unsigned int D.20764;
  unsigned char D.20765;
  int D.20768;
  unsigned int D.20769;
  unsigned int D.20770;
  unsigned int D.20771;
  struct MonoArrayBounds * D.20772;
  _Bool D.20773;
  long int D.20774;
  long int D.20775;
  unsigned int D.20778;
  unsigned int D.20779;
  int D.20780;
  struct MonoClass * klass;

  klass = vtable->klass;
  D.20758 = mono_defaults.string_class;
  if (D.20758 == klass) goto <D.20759>; else goto <D.20760>;
  <D.20759>:
  D.20762 = MEM[(struct MonoString *)o].length;
  D.20763 = D.20762 * 2;
  D.20764 = (unsigned int) D.20763;
  D.20761 = D.20764 + 14;
  return D.20761;
  <D.20760>:
  D.20765 = klass->rank;
  if (D.20765 != 0) goto <D.20766>; else goto <D.20767>;
  <D.20766>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.20768 = klass->sizes.element_size;
    D.20769 = (unsigned int) D.20768;
    D.20770 = array->max_length;
    D.20771 = D.20769 * D.20770;
    size = D.20771 + 16;
    D.20772 = array->bounds;
    D.20773 = D.20772 != 0B;
    D.20774 = (long int) D.20773;
    D.20775 = __builtin_expect (D.20774, 0);
    if (D.20775 != 0) goto <D.20776>; else goto <D.20777>;
    <D.20776>:
    size = size + 3;
    size = size & 4294967292;
    D.20765 = klass->rank;
    D.20778 = (unsigned int) D.20765;
    D.20779 = D.20778 * 8;
    size = D.20779 + size;
    <D.20777>:
    D.20761 = size;
    return D.20761;
  }
  <D.20767>:
  D.20780 = klass->instance_size;
  D.20761 = (guint) D.20780;
  return D.20761;
}


printf (const char * restrict __fmt)
{
  int D.20782;

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


sgen_check_consistency ()
{
  int gc_debug_level.31;
  _Bool D.20785;
  long int D.20786;
  long int D.20787;
  struct FILE * gc_debug_file.32;
  void (*<T36af>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.20791;
  int missing_remsets.33;
  _Bool D.20797;
  long int D.20798;
  long int D.20799;

  missing_remsets = 0;
  gc_debug_level.31 = gc_debug_level;
  D.20785 = gc_debug_level.31 > 0;
  D.20786 = (long int) D.20785;
  D.20787 = __builtin_expect (D.20786, 0);
  if (D.20787 != 0) goto <D.20788>; else goto <D.20789>;
  <D.20788>:
  gc_debug_file.32 = gc_debug_file;
  fprintf (gc_debug_file.32, "Begin heap consistency check...\n");
  gc_debug_file.32 = gc_debug_file;
  fflush (gc_debug_file.32);
  <D.20789>:
  D.20791 = major_collector.iterate_objects;
  D.20791 (1, 1, check_consistency_callback, 0B);
  sgen_los_iterate_objects (check_consistency_callback, 0B);
  gc_debug_level.31 = gc_debug_level;
  D.20785 = gc_debug_level.31 > 0;
  D.20786 = (long int) D.20785;
  D.20787 = __builtin_expect (D.20786, 0);
  if (D.20787 != 0) goto <D.20792>; else goto <D.20793>;
  <D.20792>:
  gc_debug_file.32 = gc_debug_file;
  fprintf (gc_debug_file.32, "Heap consistency check done.\n");
  gc_debug_file.32 = gc_debug_file;
  fflush (gc_debug_file.32);
  <D.20793>:
  if (1 != 0) goto <D.20794>; else goto <D.20795>;
  <D.20794>:
  missing_remsets.33 = missing_remsets;
  D.20797 = missing_remsets.33 != 0;
  D.20798 = (long int) D.20797;
  D.20799 = __builtin_expect (D.20798, 0);
  if (D.20799 != 0) goto <D.20800>; else goto <D.20801>;
  <D.20800>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 204, "!missing_remsets");
  <D.20801>:
  <D.20795>:
}


check_consistency_callback (char * start, size_t size, void * dummy)
{
  unsigned int D.20802;
  unsigned int D.20803;
  struct FILE * gc_debug_file.34;
  struct MonoClass * D.20807;
  const char * D.20808;
  unsigned int D.20809;
  unsigned int D.20810;
  unsigned int D.20813;
  unsigned int D.20814;
  unsigned int D.20815;
  unsigned int D.20816;
  unsigned int D.20817;
  void * D.20818;
  int D.20821;
  struct SgenRemeberedSet * D.20824;
  gboolean (*<T3655>) (char *) D.20825;
  int D.20826;
  int gc_debug_level.35;
  _Bool D.20830;
  long int D.20831;
  long int D.20832;
  int _objptr.36;
  int start.37;
  int D.20837;
  struct MonoVTable * D.20838;
  struct MonoClass * D.20839;
  const char * D.20840;
  const char * D.20841;
  unsigned int D.20842;
  unsigned int D.20843;
  int D.20848;
  struct SgenRemeberedSet * D.20851;
  gboolean (*<T3655>) (char *) D.20852;
  int D.20853;
  unsigned int _index.38;
  unsigned int D.20861;
  int D.20862;
  void * D.20863;
  int D.20866;
  struct SgenRemeberedSet * D.20869;
  gboolean (*<T3655>) (char *) D.20870;
  int D.20871;
  int _objptr.39;
  int D.20877;
  unsigned int D.20878;
  unsigned int D.20879;
  unsigned int _index.40;
  unsigned int D.20883;
  int D.20884;
  int D.20887;
  struct SgenRemeberedSet * D.20890;
  gboolean (*<T3655>) (char *) D.20891;
  int D.20892;
  unsigned int D.20899;
  unsigned int D.20902;
  int D.20903;
  int desc.41;
  unsigned int D.20907;
  unsigned int el_size.42;
  unsigned int D.20909;
  void * D.20910;
  int D.20913;
  struct SgenRemeberedSet * D.20916;
  gboolean (*<T3655>) (char *) D.20917;
  int D.20918;
  int p.43;
  int D.20924;
  unsigned int D.20925;
  unsigned int D.20926;
  int D.20932;
  unsigned int offset.44;
  unsigned int D.20934;
  unsigned int i.45;
  unsigned int D.20936;
  void * * D.20937;
  void * D.20938;
  int D.20941;
  struct SgenRemeberedSet * D.20944;
  gboolean (*<T3655>) (char *) D.20945;
  char * D.20946;
  int D.20947;
  int D.20952;
  int D.20953;
  unsigned int D.20954;
  unsigned int D.20955;
  sizetype el_size.46;
  unsigned int D.20962;
  void * D.20965;
  int D.20968;
  struct SgenRemeberedSet * D.20971;
  gboolean (*<T3655>) (char *) D.20972;
  int D.20973;
  int p.47;
  int D.20979;
  unsigned int D.20980;
  unsigned int D.20981;
  unsigned int D.20984;
  void * D.20987;
  int D.20990;
  struct SgenRemeberedSet * D.20993;
  gboolean (*<T3655>) (char *) D.20994;
  int D.20995;
  int _objptr.48;
  int D.21001;
  unsigned int D.21002;
  unsigned int D.21003;
  unsigned int D.21006;
  unsigned int D.21007;
  struct MonoVTable * D.21010;
  struct MonoClass * D.21011;
  const char * D.21012;
  const char * D.21013;
  gsize * bitmap_data.49;
  unsigned int D.21015;
  void * D.21018;
  int D.21021;
  struct SgenRemeberedSet * D.21024;
  gboolean (*<T3655>) (char *) D.21025;
  int D.21026;
  int _objptr.50;
  int D.21032;
  unsigned int D.21033;
  unsigned int D.21034;
  int bwords.51;
  unsigned int D.21038;
  gsize * mbitmap_data.52;
  unsigned int D.21040;
  unsigned int D.21041;
  struct MonoClass * D.21042;
  unsigned int el_size.53;
  unsigned int D.21044;
  const char * D.21047;
  const char * D.21048;
  gsize * bitmap_data.54;
  unsigned int D.21050;
  void * D.21053;
  int D.21056;
  struct SgenRemeberedSet * D.21059;
  gboolean (*<T3655>) (char *) D.21060;
  int D.21061;
  int _objptr.55;
  int D.21067;
  unsigned int D.21068;
  unsigned int D.21069;
  unsigned int bwords.56;
  sizetype el_size.57;
  struct GCVTable * vt;

  D.20802 = MEM[(mword *)start];
  D.20803 = D.20802 & 4294967292;
  vt = (struct GCVTable *) D.20803;
  if (0 != 0) goto <D.20804>; else goto <D.20805>;
  <D.20804>:
  gc_debug_file.34 = gc_debug_file;
  D.20807 = vt->klass;
  D.20808 = D.20807->name;
  fprintf (gc_debug_file.34, "Scanning object %p, vtable: %p (%s)\n", start, vt, D.20808);
  gc_debug_file.34 = gc_debug_file;
  fflush (gc_debug_file.34);
  <D.20805>:
  {
    struct GCVTable * vt;
    mword desc;

    D.20802 = MEM[(mword *)start];
    D.20803 = D.20802 & 4294967292;
    vt = (struct GCVTable *) D.20803;
    desc = vt->desc;
    D.20809 = desc & 7;
    switch (D.20809) <default: <D.19984>, case 1: <D.19899>, case 2: <D.19906>, case 3: <D.19950>, case 4: <D.19914>, case 5: <D.19944>, case 6: <D.19963>, case 7: <D.19983>>
    <D.19899>:
    D.20810 = desc & 4294901760;
    if (D.20810 != 0) goto <D.20811>; else goto <D.20812>;
    <D.20811>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.20813 = desc >> 16;
      D.20814 = D.20813 & 255;
      D.20815 = D.20814 * 4;
      _objptr = _objptr + D.20815;
      D.20816 = desc >> 24;
      D.20817 = D.20816 * 4;
      _objptr_end = _objptr + D.20817;
      D.20818 = *_objptr;
      if (D.20818 != 0B) goto <D.20819>; else goto <D.20820>;
      <D.20819>:
      D.20818 = *_objptr;
      D.20821 = sgen_ptr_in_nursery (D.20818);
      if (D.20821 != 0) goto <D.20822>; else goto <D.20823>;
      <D.20822>:
      D.20824 = sgen_get_remset ();
      D.20825 = D.20824->find_address;
      D.20826 = D.20825 (_objptr);
      if (D.20826 == 0) goto <D.20827>; else goto <D.20828>;
      <D.20827>:
      gc_debug_level.35 = gc_debug_level;
      D.20830 = gc_debug_level.35 >= 0;
      D.20831 = (long int) D.20830;
      D.20832 = __builtin_expect (D.20831, 0);
      if (D.20832 != 0) goto <D.20833>; else goto <D.20834>;
      <D.20833>:
      gc_debug_file.34 = gc_debug_file;
      D.20818 = *_objptr;
      _objptr.36 = (int) _objptr;
      start.37 = (int) start;
      D.20837 = _objptr.36 - start.37;
      D.20838 = MEM[(struct MonoObject *)start].vtable;
      D.20839 = D.20838->klass;
      D.20840 = D.20839->name_space;
      D.20838 = MEM[(struct MonoObject *)start].vtable;
      D.20839 = D.20838->klass;
      D.20841 = D.20839->name;
      fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.20818, D.20837, start, D.20840, D.20841);
      gc_debug_file.34 = gc_debug_file;
      fflush (gc_debug_file.34);
      <D.20834>:
      D.20818 = *_objptr;
      D.20842 = MEM[(mword *)D.20818];
      D.20843 = D.20842 & 2;
      if (D.20843 == 0) goto <D.20844>; else goto <D.20845>;
      <D.20844>:
      missing_remsets = 1;
      <D.20845>:
      <D.20828>:
      <D.20823>:
      <D.20820>:
      _objptr = _objptr + 4;
      goto <D.19903>;
      <D.19902>:
      D.20818 = *_objptr;
      if (D.20818 != 0B) goto <D.20846>; else goto <D.20847>;
      <D.20846>:
      D.20818 = *_objptr;
      D.20848 = sgen_ptr_in_nursery (D.20818);
      if (D.20848 != 0) goto <D.20849>; else goto <D.20850>;
      <D.20849>:
      D.20851 = sgen_get_remset ();
      D.20852 = D.20851->find_address;
      D.20853 = D.20852 (_objptr);
      if (D.20853 == 0) goto <D.20854>; else goto <D.20855>;
      <D.20854>:
      gc_debug_level.35 = gc_debug_level;
      D.20830 = gc_debug_level.35 >= 0;
      D.20831 = (long int) D.20830;
      D.20832 = __builtin_expect (D.20831, 0);
      if (D.20832 != 0) goto <D.20856>; else goto <D.20857>;
      <D.20856>:
      gc_debug_file.34 = gc_debug_file;
      D.20818 = *_objptr;
      _objptr.36 = (int) _objptr;
      start.37 = (int) start;
      D.20837 = _objptr.36 - start.37;
      D.20838 = MEM[(struct MonoObject *)start].vtable;
      D.20839 = D.20838->klass;
      D.20840 = D.20839->name_space;
      D.20838 = MEM[(struct MonoObject *)start].vtable;
      D.20839 = D.20838->klass;
      D.20841 = D.20839->name;
      fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.20818, D.20837, start, D.20840, D.20841);
      gc_debug_file.34 = gc_debug_file;
      fflush (gc_debug_file.34);
      <D.20857>:
      D.20818 = *_objptr;
      D.20842 = MEM[(mword *)D.20818];
      D.20843 = D.20842 & 2;
      if (D.20843 == 0) goto <D.20858>; else goto <D.20859>;
      <D.20858>:
      missing_remsets = 1;
      <D.20859>:
      <D.20855>:
      <D.20850>:
      <D.20847>:
      _objptr = _objptr + 4;
      <D.19903>:
      if (_objptr < _objptr_end) goto <D.19902>; else goto <D.19904>;
      <D.19904>:
    }
    <D.20812>:
    goto <D.19905>;
    <D.19906>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.38 = (unsigned int) _index;
        D.20861 = _index.38 * 4;
        _objptr = _objptr + D.20861;
        D.20862 = _index + 1;
        _bmap = _bmap >> D.20862;
        D.20863 = *_objptr;
        if (D.20863 != 0B) goto <D.20864>; else goto <D.20865>;
        <D.20864>:
        D.20863 = *_objptr;
        D.20866 = sgen_ptr_in_nursery (D.20863);
        if (D.20866 != 0) goto <D.20867>; else goto <D.20868>;
        <D.20867>:
        D.20869 = sgen_get_remset ();
        D.20870 = D.20869->find_address;
        D.20871 = D.20870 (_objptr);
        if (D.20871 == 0) goto <D.20872>; else goto <D.20873>;
        <D.20872>:
        gc_debug_level.35 = gc_debug_level;
        D.20830 = gc_debug_level.35 >= 0;
        D.20831 = (long int) D.20830;
        D.20832 = __builtin_expect (D.20831, 0);
        if (D.20832 != 0) goto <D.20874>; else goto <D.20875>;
        <D.20874>:
        gc_debug_file.34 = gc_debug_file;
        D.20863 = *_objptr;
        _objptr.39 = (int) _objptr;
        start.37 = (int) start;
        D.20877 = _objptr.39 - start.37;
        D.20838 = MEM[(struct MonoObject *)start].vtable;
        D.20839 = D.20838->klass;
        D.20840 = D.20839->name_space;
        D.20838 = MEM[(struct MonoObject *)start].vtable;
        D.20839 = D.20838->klass;
        D.20841 = D.20839->name;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.20863, D.20877, start, D.20840, D.20841);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.20875>:
        D.20863 = *_objptr;
        D.20878 = MEM[(mword *)D.20863];
        D.20879 = D.20878 & 2;
        if (D.20879 == 0) goto <D.20880>; else goto <D.20881>;
        <D.20880>:
        missing_remsets = 1;
        <D.20881>:
        <D.20873>:
        <D.20868>:
        <D.20865>:
        _objptr = _objptr + 4;
      }
      goto <D.19912>;
      <D.19911>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.40 = (unsigned int) _index;
        D.20883 = _index.40 * 4;
        _objptr = _objptr + D.20883;
        D.20884 = _index + 1;
        _bmap = _bmap >> D.20884;
        D.20863 = *_objptr;
        if (D.20863 != 0B) goto <D.20885>; else goto <D.20886>;
        <D.20885>:
        D.20863 = *_objptr;
        D.20887 = sgen_ptr_in_nursery (D.20863);
        if (D.20887 != 0) goto <D.20888>; else goto <D.20889>;
        <D.20888>:
        D.20890 = sgen_get_remset ();
        D.20891 = D.20890->find_address;
        D.20892 = D.20891 (_objptr);
        if (D.20892 == 0) goto <D.20893>; else goto <D.20894>;
        <D.20893>:
        gc_debug_level.35 = gc_debug_level;
        D.20830 = gc_debug_level.35 >= 0;
        D.20831 = (long int) D.20830;
        D.20832 = __builtin_expect (D.20831, 0);
        if (D.20832 != 0) goto <D.20895>; else goto <D.20896>;
        <D.20895>:
        gc_debug_file.34 = gc_debug_file;
        D.20863 = *_objptr;
        _objptr.39 = (int) _objptr;
        start.37 = (int) start;
        D.20877 = _objptr.39 - start.37;
        D.20838 = MEM[(struct MonoObject *)start].vtable;
        D.20839 = D.20838->klass;
        D.20840 = D.20839->name_space;
        D.20838 = MEM[(struct MonoObject *)start].vtable;
        D.20839 = D.20838->klass;
        D.20841 = D.20839->name;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.20863, D.20877, start, D.20840, D.20841);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.20896>:
        D.20863 = *_objptr;
        D.20878 = MEM[(mword *)D.20863];
        D.20879 = D.20878 & 2;
        if (D.20879 == 0) goto <D.20897>; else goto <D.20898>;
        <D.20897>:
        missing_remsets = 1;
        <D.20898>:
        <D.20894>:
        <D.20889>:
        <D.20886>:
        _objptr = _objptr + 4;
      }
      <D.19912>:
      if (_bmap != 0) goto <D.19911>; else goto <D.19913>;
      <D.19913>:
    }
    goto <D.19905>;
    <D.19914>:
    D.20899 = desc & 4294950912;
    if (D.20899 != 0) goto <D.20900>; else goto <D.20901>;
    <D.20900>:
    {
      int el_size;
      int etype;

      D.20902 = desc >> 3;
      D.20903 = (int) D.20902;
      el_size = D.20903 & 1023;
      desc.41 = (int) desc;
      etype = desc.41 & 49152;
      if (etype == 16384) goto <D.20905>; else goto <D.20906>;
      <D.20905>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.20907 = MEM[(struct MonoArray *)start].max_length;
        el_size.42 = (unsigned int) el_size;
        D.20909 = D.20907 * el_size.42;
        end_refs = p + D.20909;
        goto <D.19920>;
        <D.19919>:
        D.20910 = *p;
        if (D.20910 != 0B) goto <D.20911>; else goto <D.20912>;
        <D.20911>:
        D.20910 = *p;
        D.20913 = sgen_ptr_in_nursery (D.20910);
        if (D.20913 != 0) goto <D.20914>; else goto <D.20915>;
        <D.20914>:
        D.20916 = sgen_get_remset ();
        D.20917 = D.20916->find_address;
        D.20918 = D.20917 (p);
        if (D.20918 == 0) goto <D.20919>; else goto <D.20920>;
        <D.20919>:
        gc_debug_level.35 = gc_debug_level;
        D.20830 = gc_debug_level.35 >= 0;
        D.20831 = (long int) D.20830;
        D.20832 = __builtin_expect (D.20831, 0);
        if (D.20832 != 0) goto <D.20921>; else goto <D.20922>;
        <D.20921>:
        gc_debug_file.34 = gc_debug_file;
        D.20910 = *p;
        p.43 = (int) p;
        start.37 = (int) start;
        D.20924 = p.43 - start.37;
        D.20838 = MEM[(struct MonoObject *)start].vtable;
        D.20839 = D.20838->klass;
        D.20840 = D.20839->name_space;
        D.20838 = MEM[(struct MonoObject *)start].vtable;
        D.20839 = D.20838->klass;
        D.20841 = D.20839->name;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.20910, D.20924, start, D.20840, D.20841);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.20922>:
        D.20910 = *p;
        D.20925 = MEM[(mword *)D.20910];
        D.20926 = D.20925 & 2;
        if (D.20926 == 0) goto <D.20927>; else goto <D.20928>;
        <D.20927>:
        missing_remsets = 1;
        <D.20928>:
        <D.20920>:
        <D.20915>:
        <D.20912>:
        p = p + 4;
        <D.19920>:
        if (p < end_refs) goto <D.19919>; else goto <D.19921>;
        <D.19921>:
      }
      goto <D.20929>;
      <D.20906>:
      if (etype == 32768) goto <D.20930>; else goto <D.20931>;
      <D.20930>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.20813 = desc >> 16;
        D.20932 = (int) D.20813;
        offset = D.20932 & 255;
        D.20816 = desc >> 24;
        num_refs = (int) D.20816;
        e_start = start + 16;
        D.20907 = MEM[(struct MonoArray *)start].max_length;
        el_size.42 = (unsigned int) el_size;
        D.20909 = D.20907 * el_size.42;
        e_end = e_start + D.20909;
        goto <D.19932>;
        <D.19931>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.44 = (unsigned int) offset;
          D.20934 = offset.44 * 4;
          p = p + D.20934;
          i = 0;
          goto <D.19929>;
          <D.19928>:
          i.45 = (unsigned int) i;
          D.20936 = i.45 * 4;
          D.20937 = p + D.20936;
          D.20938 = *D.20937;
          if (D.20938 != 0B) goto <D.20939>; else goto <D.20940>;
          <D.20939>:
          i.45 = (unsigned int) i;
          D.20936 = i.45 * 4;
          D.20937 = p + D.20936;
          D.20938 = *D.20937;
          D.20941 = sgen_ptr_in_nursery (D.20938);
          if (D.20941 != 0) goto <D.20942>; else goto <D.20943>;
          <D.20942>:
          D.20944 = sgen_get_remset ();
          D.20945 = D.20944->find_address;
          i.45 = (unsigned int) i;
          D.20936 = i.45 * 4;
          D.20946 = p + D.20936;
          D.20947 = D.20945 (D.20946);
          if (D.20947 == 0) goto <D.20948>; else goto <D.20949>;
          <D.20948>:
          gc_debug_level.35 = gc_debug_level;
          D.20830 = gc_debug_level.35 >= 0;
          D.20831 = (long int) D.20830;
          D.20832 = __builtin_expect (D.20831, 0);
          if (D.20832 != 0) goto <D.20950>; else goto <D.20951>;
          <D.20950>:
          gc_debug_file.34 = gc_debug_file;
          i.45 = (unsigned int) i;
          D.20936 = i.45 * 4;
          D.20937 = p + D.20936;
          D.20938 = *D.20937;
          i.45 = (unsigned int) i;
          D.20936 = i.45 * 4;
          D.20946 = p + D.20936;
          D.20952 = (int) D.20946;
          start.37 = (int) start;
          D.20953 = D.20952 - start.37;
          D.20838 = MEM[(struct MonoObject *)start].vtable;
          D.20839 = D.20838->klass;
          D.20840 = D.20839->name_space;
          D.20838 = MEM[(struct MonoObject *)start].vtable;
          D.20839 = D.20838->klass;
          D.20841 = D.20839->name;
          fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.20938, D.20953, start, D.20840, D.20841);
          gc_debug_file.34 = gc_debug_file;
          fflush (gc_debug_file.34);
          <D.20951>:
          i.45 = (unsigned int) i;
          D.20936 = i.45 * 4;
          D.20937 = p + D.20936;
          D.20938 = *D.20937;
          D.20954 = MEM[(mword *)D.20938];
          D.20955 = D.20954 & 2;
          if (D.20955 == 0) goto <D.20956>; else goto <D.20957>;
          <D.20956>:
          missing_remsets = 1;
          <D.20957>:
          <D.20949>:
          <D.20943>:
          <D.20940>:
          i = i + 1;
          <D.19929>:
          if (i < num_refs) goto <D.19928>; else goto <D.19930>;
          <D.19930>:
          el_size.46 = (sizetype) el_size;
          e_start = e_start + el_size.46;
        }
        <D.19932>:
        if (e_start < e_end) goto <D.19931>; else goto <D.19933>;
        <D.19933>:
      }
      goto <D.20959>;
      <D.20931>:
      if (etype == 49152) goto <D.20960>; else goto <D.20961>;
      <D.20960>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.20907 = MEM[(struct MonoArray *)start].max_length;
        el_size.42 = (unsigned int) el_size;
        D.20909 = D.20907 * el_size.42;
        e_end = e_start + D.20909;
        goto <D.19942>;
        <D.19941>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.19939>;
          <D.19938>:
          D.20962 = _bmap & 1;
          if (D.20962 != 0) goto <D.20963>; else goto <D.20964>;
          <D.20963>:
          D.20965 = *p;
          if (D.20965 != 0B) goto <D.20966>; else goto <D.20967>;
          <D.20966>:
          D.20965 = *p;
          D.20968 = sgen_ptr_in_nursery (D.20965);
          if (D.20968 != 0) goto <D.20969>; else goto <D.20970>;
          <D.20969>:
          D.20971 = sgen_get_remset ();
          D.20972 = D.20971->find_address;
          D.20973 = D.20972 (p);
          if (D.20973 == 0) goto <D.20974>; else goto <D.20975>;
          <D.20974>:
          gc_debug_level.35 = gc_debug_level;
          D.20830 = gc_debug_level.35 >= 0;
          D.20831 = (long int) D.20830;
          D.20832 = __builtin_expect (D.20831, 0);
          if (D.20832 != 0) goto <D.20976>; else goto <D.20977>;
          <D.20976>:
          gc_debug_file.34 = gc_debug_file;
          D.20965 = *p;
          p.47 = (int) p;
          start.37 = (int) start;
          D.20979 = p.47 - start.37;
          D.20838 = MEM[(struct MonoObject *)start].vtable;
          D.20839 = D.20838->klass;
          D.20840 = D.20839->name_space;
          D.20838 = MEM[(struct MonoObject *)start].vtable;
          D.20839 = D.20838->klass;
          D.20841 = D.20839->name;
          fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.20965, D.20979, start, D.20840, D.20841);
          gc_debug_file.34 = gc_debug_file;
          fflush (gc_debug_file.34);
          <D.20977>:
          D.20965 = *p;
          D.20980 = MEM[(mword *)D.20965];
          D.20981 = D.20980 & 2;
          if (D.20981 == 0) goto <D.20982>; else goto <D.20983>;
          <D.20982>:
          missing_remsets = 1;
          <D.20983>:
          <D.20975>:
          <D.20970>:
          <D.20967>:
          <D.20964>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.19939>:
          if (_bmap != 0) goto <D.19938>; else goto <D.19940>;
          <D.19940>:
          el_size.46 = (sizetype) el_size;
          e_start = e_start + el_size.46;
        }
        <D.19942>:
        if (e_start < e_end) goto <D.19941>; else goto <D.19943>;
        <D.19943>:
      }
      <D.20961>:
      <D.20959>:
      <D.20929>:
    }
    <D.20901>:
    goto <D.19905>;
    <D.19944>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.19948>;
      <D.19947>:
      D.20984 = _bmap & 1;
      if (D.20984 != 0) goto <D.20985>; else goto <D.20986>;
      <D.20985>:
      D.20987 = *_objptr;
      if (D.20987 != 0B) goto <D.20988>; else goto <D.20989>;
      <D.20988>:
      D.20987 = *_objptr;
      D.20990 = sgen_ptr_in_nursery (D.20987);
      if (D.20990 != 0) goto <D.20991>; else goto <D.20992>;
      <D.20991>:
      D.20993 = sgen_get_remset ();
      D.20994 = D.20993->find_address;
      D.20995 = D.20994 (_objptr);
      if (D.20995 == 0) goto <D.20996>; else goto <D.20997>;
      <D.20996>:
      gc_debug_level.35 = gc_debug_level;
      D.20830 = gc_debug_level.35 >= 0;
      D.20831 = (long int) D.20830;
      D.20832 = __builtin_expect (D.20831, 0);
      if (D.20832 != 0) goto <D.20998>; else goto <D.20999>;
      <D.20998>:
      gc_debug_file.34 = gc_debug_file;
      D.20987 = *_objptr;
      _objptr.48 = (int) _objptr;
      start.37 = (int) start;
      D.21001 = _objptr.48 - start.37;
      D.20838 = MEM[(struct MonoObject *)start].vtable;
      D.20839 = D.20838->klass;
      D.20840 = D.20839->name_space;
      D.20838 = MEM[(struct MonoObject *)start].vtable;
      D.20839 = D.20838->klass;
      D.20841 = D.20839->name;
      fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.20987, D.21001, start, D.20840, D.20841);
      gc_debug_file.34 = gc_debug_file;
      fflush (gc_debug_file.34);
      <D.20999>:
      D.20987 = *_objptr;
      D.21002 = MEM[(mword *)D.20987];
      D.21003 = D.21002 & 2;
      if (D.21003 == 0) goto <D.21004>; else goto <D.21005>;
      <D.21004>:
      missing_remsets = 1;
      <D.21005>:
      <D.20997>:
      <D.20992>:
      <D.20989>:
      <D.20986>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.19948>:
      if (_bmap != 0) goto <D.19947>; else goto <D.19949>;
      <D.19949>:
    }
    goto <D.19905>;
    <D.19950>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.21006 = *bitmap_data;
      D.21007 = D.21006 + 4294967295;
      bwords = (int) D.21007;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.21008>; else goto <D.21009>;
      <D.21008>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.21010 = myobj->vtable;
        D.21011 = D.21010->klass;
        D.21012 = D.21011->name_space;
        D.21010 = myobj->vtable;
        D.21011 = D.21010->klass;
        D.21013 = D.21011->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21012, D.21013);
      }
      <D.21009>:
      goto <D.19961>;
      <D.19960>:
      {
        gsize _bmap;

        bitmap_data.49 = bitmap_data;
        bitmap_data = bitmap_data.49 + 4;
        _bmap = *bitmap_data.49;
        _objptr = start_run;
        goto <D.19958>;
        <D.19957>:
        D.21015 = _bmap & 1;
        if (D.21015 != 0) goto <D.21016>; else goto <D.21017>;
        <D.21016>:
        D.21018 = *_objptr;
        if (D.21018 != 0B) goto <D.21019>; else goto <D.21020>;
        <D.21019>:
        D.21018 = *_objptr;
        D.21021 = sgen_ptr_in_nursery (D.21018);
        if (D.21021 != 0) goto <D.21022>; else goto <D.21023>;
        <D.21022>:
        D.21024 = sgen_get_remset ();
        D.21025 = D.21024->find_address;
        D.21026 = D.21025 (_objptr);
        if (D.21026 == 0) goto <D.21027>; else goto <D.21028>;
        <D.21027>:
        gc_debug_level.35 = gc_debug_level;
        D.20830 = gc_debug_level.35 >= 0;
        D.20831 = (long int) D.20830;
        D.20832 = __builtin_expect (D.20831, 0);
        if (D.20832 != 0) goto <D.21029>; else goto <D.21030>;
        <D.21029>:
        gc_debug_file.34 = gc_debug_file;
        D.21018 = *_objptr;
        _objptr.50 = (int) _objptr;
        start.37 = (int) start;
        D.21032 = _objptr.50 - start.37;
        D.20838 = MEM[(struct MonoObject *)start].vtable;
        D.20839 = D.20838->klass;
        D.20840 = D.20839->name_space;
        D.20838 = MEM[(struct MonoObject *)start].vtable;
        D.20839 = D.20838->klass;
        D.20841 = D.20839->name;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21018, D.21032, start, D.20840, D.20841);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.21030>:
        D.21018 = *_objptr;
        D.21033 = MEM[(mword *)D.21018];
        D.21034 = D.21033 & 2;
        if (D.21034 == 0) goto <D.21035>; else goto <D.21036>;
        <D.21035>:
        missing_remsets = 1;
        <D.21036>:
        <D.21028>:
        <D.21023>:
        <D.21020>:
        <D.21017>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.19958>:
        if (_bmap != 0) goto <D.19957>; else goto <D.19959>;
        <D.19959>:
        start_run = start_run + 128;
      }
      <D.19961>:
      bwords.51 = bwords;
      bwords = bwords.51 + -1;
      if (bwords.51 > 0) goto <D.19960>; else goto <D.19962>;
      <D.19962>:
    }
    goto <D.19905>;
    <D.19963>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.21038 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.21038);
      mbitmap_data.52 = mbitmap_data;
      mbitmap_data = mbitmap_data.52 + 4;
      D.21040 = *mbitmap_data.52;
      D.21041 = D.21040 + 4294967295;
      mbwords = (int) D.21041;
      D.21042 = vt->klass;
      el_size = mono_array_element_size (D.21042);
      e_start = start + 16;
      D.20907 = MEM[(struct MonoArray *)start].max_length;
      el_size.53 = (unsigned int) el_size;
      D.21044 = D.20907 * el_size.53;
      e_end = e_start + D.21044;
      if (0 != 0) goto <D.21045>; else goto <D.21046>;
      <D.21045>:
      D.21038 = vt->desc;
      D.21042 = vt->klass;
      D.21047 = D.21042->name_space;
      D.21042 = vt->klass;
      D.21048 = D.21042->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.21038, D.21047, D.21048);
      <D.21046>:
      goto <D.19981>;
      <D.19980>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.54 = bitmap_data;
          bitmap_data = bitmap_data.54 + 4;
          _bmap = *bitmap_data.54;
          start_run = _objptr;
          goto <D.19975>;
          <D.19974>:
          D.21050 = _bmap & 1;
          if (D.21050 != 0) goto <D.21051>; else goto <D.21052>;
          <D.21051>:
          D.21053 = *_objptr;
          if (D.21053 != 0B) goto <D.21054>; else goto <D.21055>;
          <D.21054>:
          D.21053 = *_objptr;
          D.21056 = sgen_ptr_in_nursery (D.21053);
          if (D.21056 != 0) goto <D.21057>; else goto <D.21058>;
          <D.21057>:
          D.21059 = sgen_get_remset ();
          D.21060 = D.21059->find_address;
          D.21061 = D.21060 (_objptr);
          if (D.21061 == 0) goto <D.21062>; else goto <D.21063>;
          <D.21062>:
          gc_debug_level.35 = gc_debug_level;
          D.20830 = gc_debug_level.35 >= 0;
          D.20831 = (long int) D.20830;
          D.20832 = __builtin_expect (D.20831, 0);
          if (D.20832 != 0) goto <D.21064>; else goto <D.21065>;
          <D.21064>:
          gc_debug_file.34 = gc_debug_file;
          D.21053 = *_objptr;
          _objptr.55 = (int) _objptr;
          start.37 = (int) start;
          D.21067 = _objptr.55 - start.37;
          D.20838 = MEM[(struct MonoObject *)start].vtable;
          D.20839 = D.20838->klass;
          D.20840 = D.20839->name_space;
          D.20838 = MEM[(struct MonoObject *)start].vtable;
          D.20839 = D.20838->klass;
          D.20841 = D.20839->name;
          fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21053, D.21067, start, D.20840, D.20841);
          gc_debug_file.34 = gc_debug_file;
          fflush (gc_debug_file.34);
          <D.21065>:
          D.21053 = *_objptr;
          D.21068 = MEM[(mword *)D.21053];
          D.21069 = D.21068 & 2;
          if (D.21069 == 0) goto <D.21070>; else goto <D.21071>;
          <D.21070>:
          missing_remsets = 1;
          <D.21071>:
          <D.21063>:
          <D.21058>:
          <D.21055>:
          <D.21052>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.19975>:
          if (_bmap != 0) goto <D.19974>; else goto <D.19976>;
          <D.19976>:
          _objptr = start_run + 128;
        }
        <D.19978>:
        bwords.56 = bwords;
        bwords = bwords.56 + 4294967295;
        if (bwords.56 != 0) goto <D.19977>; else goto <D.19979>;
        <D.19979>:
        el_size.57 = (sizetype) el_size;
        e_start = e_start + el_size.57;
      }
      <D.19981>:
      if (e_start < e_end) goto <D.19980>; else goto <D.19982>;
      <D.19982>:
    }
    goto <D.19905>;
    <D.19983>:
    goto <D.19905>;
    <D.19984>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.19905>:
  }
}


sgen_check_mod_union_consistency ()
{
  void (*<T36af>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.21075;
  int missing_remsets.58;
  _Bool D.21079;
  long int D.21080;
  long int D.21081;

  missing_remsets = 0;
  D.21075 = major_collector.iterate_objects;
  D.21075 (1, 1, check_mod_union_callback, 0B);
  sgen_los_iterate_objects (check_mod_union_callback, 1B);
  if (1 != 0) goto <D.21076>; else goto <D.21077>;
  <D.21076>:
  missing_remsets.58 = missing_remsets;
  D.21079 = missing_remsets.58 != 0;
  D.21080 = (long int) D.21079;
  D.21081 = __builtin_expect (D.21080, 0);
  if (D.21081 != 0) goto <D.21082>; else goto <D.21083>;
  <D.21082>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 258, "!missing_remsets");
  <D.21083>:
  <D.21077>:
}


check_mod_union_callback (char * start, size_t size, void * dummy)
{
  unsigned int D.21084;
  unsigned int D.21085;
  struct FILE * gc_debug_file.59;
  struct MonoClass * D.21089;
  const char * D.21090;
  int D.21091;
  struct LOSObject * D.21096;
  struct SgenMajorCollector * D.21098;
  guint8 * (*<T36f2>) (char *) D.21099;
  _Bool D.21100;
  long int D.21101;
  long int D.21102;
  unsigned int D.21105;
  unsigned int D.21106;
  unsigned int D.21109;
  unsigned int D.21110;
  unsigned int D.21111;
  unsigned int D.21112;
  unsigned int D.21113;
  void * D.21114;
  int D.21117;
  int D.21120;
  struct SgenRemeberedSet * D.21123;
  gboolean (*<T3730>) (char *, guint8 *, char *) D.21124;
  int D.21125;
  int gc_debug_level.60;
  _Bool D.21129;
  long int D.21130;
  long int D.21131;
  int _objptr.61;
  int start.62;
  int D.21136;
  struct MonoVTable * D.21137;
  struct MonoClass * D.21138;
  const char * D.21139;
  const char * D.21140;
  int D.21143;
  int D.21146;
  struct SgenRemeberedSet * D.21149;
  gboolean (*<T3730>) (char *, guint8 *, char *) D.21150;
  int D.21151;
  unsigned int _index.63;
  unsigned int D.21157;
  int D.21158;
  void * D.21159;
  int D.21162;
  int D.21165;
  struct SgenRemeberedSet * D.21168;
  gboolean (*<T3730>) (char *, guint8 *, char *) D.21169;
  int D.21170;
  int _objptr.64;
  int D.21176;
  unsigned int _index.65;
  unsigned int D.21178;
  int D.21179;
  int D.21182;
  int D.21185;
  struct SgenRemeberedSet * D.21188;
  gboolean (*<T3730>) (char *, guint8 *, char *) D.21189;
  int D.21190;
  unsigned int D.21195;
  unsigned int D.21198;
  int D.21199;
  int desc.66;
  unsigned int D.21203;
  unsigned int el_size.67;
  unsigned int D.21205;
  void * D.21206;
  int D.21209;
  int D.21212;
  struct SgenRemeberedSet * D.21215;
  gboolean (*<T3730>) (char *, guint8 *, char *) D.21216;
  int D.21217;
  int p.68;
  int D.21223;
  int D.21227;
  unsigned int offset.69;
  unsigned int D.21229;
  unsigned int i.70;
  unsigned int D.21231;
  void * * D.21232;
  void * D.21233;
  int D.21236;
  int D.21239;
  struct SgenRemeberedSet * D.21242;
  gboolean (*<T3730>) (char *, guint8 *, char *) D.21243;
  char * D.21244;
  int D.21245;
  int D.21250;
  int D.21251;
  sizetype el_size.71;
  unsigned int D.21256;
  void * D.21259;
  int D.21262;
  int D.21265;
  struct SgenRemeberedSet * D.21268;
  gboolean (*<T3730>) (char *, guint8 *, char *) D.21269;
  int D.21270;
  int p.72;
  int D.21276;
  unsigned int D.21277;
  void * D.21280;
  int D.21283;
  int D.21286;
  struct SgenRemeberedSet * D.21289;
  gboolean (*<T3730>) (char *, guint8 *, char *) D.21290;
  int D.21291;
  int _objptr.73;
  int D.21297;
  unsigned int D.21298;
  unsigned int D.21299;
  struct MonoVTable * D.21302;
  struct MonoClass * D.21303;
  const char * D.21304;
  const char * D.21305;
  gsize * bitmap_data.74;
  unsigned int D.21307;
  void * D.21310;
  int D.21313;
  int D.21316;
  struct SgenRemeberedSet * D.21319;
  gboolean (*<T3730>) (char *, guint8 *, char *) D.21320;
  int D.21321;
  int _objptr.75;
  int D.21327;
  int bwords.76;
  unsigned int D.21329;
  gsize * mbitmap_data.77;
  unsigned int D.21331;
  unsigned int D.21332;
  struct MonoClass * D.21333;
  unsigned int el_size.78;
  unsigned int D.21335;
  const char * D.21338;
  const char * D.21339;
  gsize * bitmap_data.79;
  unsigned int D.21341;
  void * D.21344;
  int D.21347;
  int D.21350;
  struct SgenRemeberedSet * D.21353;
  gboolean (*<T3730>) (char *, guint8 *, char *) D.21354;
  int D.21355;
  int _objptr.80;
  int D.21361;
  unsigned int bwords.81;
  sizetype el_size.82;
  gboolean in_los;
  struct GCVTable * vt;
  guint8 * cards;

  in_los = (gboolean) dummy;
  D.21084 = MEM[(mword *)start];
  D.21085 = D.21084 & 4294967292;
  vt = (struct GCVTable *) D.21085;
  if (0 != 0) goto <D.21086>; else goto <D.21087>;
  <D.21086>:
  gc_debug_file.59 = gc_debug_file;
  D.21089 = vt->klass;
  D.21090 = D.21089->name;
  fprintf (gc_debug_file.59, "Scanning object %p, vtable: %p (%s)\n", start, vt, D.21090);
  gc_debug_file.59 = gc_debug_file;
  fflush (gc_debug_file.59);
  <D.21087>:
  D.21091 = is_major_or_los_object_marked (start);
  if (D.21091 == 0) goto <D.21092>; else goto <D.21093>;
  <D.21092>:
  return;
  <D.21093>:
  if (in_los != 0) goto <D.21094>; else goto <D.21095>;
  <D.21094>:
  D.21096 = sgen_los_header_for_object (start);
  cards = D.21096->cardtable_mod_union;
  goto <D.21097>;
  <D.21095>:
  D.21098 = sgen_get_major_collector ();
  D.21099 = D.21098->get_cardtable_mod_union_for_object;
  cards = D.21099 (start);
  <D.21097>:
  D.21100 = cards == 0B;
  D.21101 = (long int) D.21100;
  D.21102 = __builtin_expect (D.21101, 0);
  if (D.21102 != 0) goto <D.21103>; else goto <D.21104>;
  <D.21103>:
  monoeg_g_log (0B, 4, "we must have mod union for marked major objects");
  <D.19999>:
  goto <D.19999>;
  <D.21104>:
  {
    struct GCVTable * vt;
    mword desc;

    D.21084 = MEM[(mword *)start];
    D.21085 = D.21084 & 4294967292;
    vt = (struct GCVTable *) D.21085;
    desc = vt->desc;
    D.21105 = desc & 7;
    switch (D.21105) <default: <D.20087>, case 1: <D.20002>, case 2: <D.20009>, case 3: <D.20053>, case 4: <D.20017>, case 5: <D.20047>, case 6: <D.20066>, case 7: <D.20086>>
    <D.20002>:
    D.21106 = desc & 4294901760;
    if (D.21106 != 0) goto <D.21107>; else goto <D.21108>;
    <D.21107>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.21109 = desc >> 16;
      D.21110 = D.21109 & 255;
      D.21111 = D.21110 * 4;
      _objptr = _objptr + D.21111;
      D.21112 = desc >> 24;
      D.21113 = D.21112 * 4;
      _objptr_end = _objptr + D.21113;
      D.21114 = *_objptr;
      if (D.21114 != 0B) goto <D.21115>; else goto <D.21116>;
      <D.21115>:
      D.21114 = *_objptr;
      D.21117 = sgen_ptr_in_nursery (D.21114);
      if (D.21117 == 0) goto <D.21118>; else goto <D.21119>;
      <D.21118>:
      D.21114 = *_objptr;
      D.21120 = is_major_or_los_object_marked (D.21114);
      if (D.21120 == 0) goto <D.21121>; else goto <D.21122>;
      <D.21121>:
      D.21123 = sgen_get_remset ();
      D.21124 = D.21123->find_address_with_cards;
      D.21125 = D.21124 (start, cards, _objptr);
      if (D.21125 == 0) goto <D.21126>; else goto <D.21127>;
      <D.21126>:
      gc_debug_level.60 = gc_debug_level;
      D.21129 = gc_debug_level.60 >= 0;
      D.21130 = (long int) D.21129;
      D.21131 = __builtin_expect (D.21130, 0);
      if (D.21131 != 0) goto <D.21132>; else goto <D.21133>;
      <D.21132>:
      gc_debug_file.59 = gc_debug_file;
      D.21114 = *_objptr;
      _objptr.61 = (int) _objptr;
      start.62 = (int) start;
      D.21136 = _objptr.61 - start.62;
      D.21137 = MEM[(struct MonoObject *)start].vtable;
      D.21138 = D.21137->klass;
      D.21139 = D.21138->name_space;
      D.21137 = MEM[(struct MonoObject *)start].vtable;
      D.21138 = D.21137->klass;
      D.21140 = D.21138->name;
      fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21114, D.21136, start, D.21139, D.21140);
      gc_debug_file.59 = gc_debug_file;
      fflush (gc_debug_file.59);
      <D.21133>:
      <D.21127>:
      <D.21122>:
      <D.21119>:
      <D.21116>:
      _objptr = _objptr + 4;
      goto <D.20006>;
      <D.20005>:
      D.21114 = *_objptr;
      if (D.21114 != 0B) goto <D.21141>; else goto <D.21142>;
      <D.21141>:
      D.21114 = *_objptr;
      D.21143 = sgen_ptr_in_nursery (D.21114);
      if (D.21143 == 0) goto <D.21144>; else goto <D.21145>;
      <D.21144>:
      D.21114 = *_objptr;
      D.21146 = is_major_or_los_object_marked (D.21114);
      if (D.21146 == 0) goto <D.21147>; else goto <D.21148>;
      <D.21147>:
      D.21149 = sgen_get_remset ();
      D.21150 = D.21149->find_address_with_cards;
      D.21151 = D.21150 (start, cards, _objptr);
      if (D.21151 == 0) goto <D.21152>; else goto <D.21153>;
      <D.21152>:
      gc_debug_level.60 = gc_debug_level;
      D.21129 = gc_debug_level.60 >= 0;
      D.21130 = (long int) D.21129;
      D.21131 = __builtin_expect (D.21130, 0);
      if (D.21131 != 0) goto <D.21154>; else goto <D.21155>;
      <D.21154>:
      gc_debug_file.59 = gc_debug_file;
      D.21114 = *_objptr;
      _objptr.61 = (int) _objptr;
      start.62 = (int) start;
      D.21136 = _objptr.61 - start.62;
      D.21137 = MEM[(struct MonoObject *)start].vtable;
      D.21138 = D.21137->klass;
      D.21139 = D.21138->name_space;
      D.21137 = MEM[(struct MonoObject *)start].vtable;
      D.21138 = D.21137->klass;
      D.21140 = D.21138->name;
      fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21114, D.21136, start, D.21139, D.21140);
      gc_debug_file.59 = gc_debug_file;
      fflush (gc_debug_file.59);
      <D.21155>:
      <D.21153>:
      <D.21148>:
      <D.21145>:
      <D.21142>:
      _objptr = _objptr + 4;
      <D.20006>:
      if (_objptr < _objptr_end) goto <D.20005>; else goto <D.20007>;
      <D.20007>:
    }
    <D.21108>:
    goto <D.20008>;
    <D.20009>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.63 = (unsigned int) _index;
        D.21157 = _index.63 * 4;
        _objptr = _objptr + D.21157;
        D.21158 = _index + 1;
        _bmap = _bmap >> D.21158;
        D.21159 = *_objptr;
        if (D.21159 != 0B) goto <D.21160>; else goto <D.21161>;
        <D.21160>:
        D.21159 = *_objptr;
        D.21162 = sgen_ptr_in_nursery (D.21159);
        if (D.21162 == 0) goto <D.21163>; else goto <D.21164>;
        <D.21163>:
        D.21159 = *_objptr;
        D.21165 = is_major_or_los_object_marked (D.21159);
        if (D.21165 == 0) goto <D.21166>; else goto <D.21167>;
        <D.21166>:
        D.21168 = sgen_get_remset ();
        D.21169 = D.21168->find_address_with_cards;
        D.21170 = D.21169 (start, cards, _objptr);
        if (D.21170 == 0) goto <D.21171>; else goto <D.21172>;
        <D.21171>:
        gc_debug_level.60 = gc_debug_level;
        D.21129 = gc_debug_level.60 >= 0;
        D.21130 = (long int) D.21129;
        D.21131 = __builtin_expect (D.21130, 0);
        if (D.21131 != 0) goto <D.21173>; else goto <D.21174>;
        <D.21173>:
        gc_debug_file.59 = gc_debug_file;
        D.21159 = *_objptr;
        _objptr.64 = (int) _objptr;
        start.62 = (int) start;
        D.21176 = _objptr.64 - start.62;
        D.21137 = MEM[(struct MonoObject *)start].vtable;
        D.21138 = D.21137->klass;
        D.21139 = D.21138->name_space;
        D.21137 = MEM[(struct MonoObject *)start].vtable;
        D.21138 = D.21137->klass;
        D.21140 = D.21138->name;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21159, D.21176, start, D.21139, D.21140);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.21174>:
        <D.21172>:
        <D.21167>:
        <D.21164>:
        <D.21161>:
        _objptr = _objptr + 4;
      }
      goto <D.20015>;
      <D.20014>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.65 = (unsigned int) _index;
        D.21178 = _index.65 * 4;
        _objptr = _objptr + D.21178;
        D.21179 = _index + 1;
        _bmap = _bmap >> D.21179;
        D.21159 = *_objptr;
        if (D.21159 != 0B) goto <D.21180>; else goto <D.21181>;
        <D.21180>:
        D.21159 = *_objptr;
        D.21182 = sgen_ptr_in_nursery (D.21159);
        if (D.21182 == 0) goto <D.21183>; else goto <D.21184>;
        <D.21183>:
        D.21159 = *_objptr;
        D.21185 = is_major_or_los_object_marked (D.21159);
        if (D.21185 == 0) goto <D.21186>; else goto <D.21187>;
        <D.21186>:
        D.21188 = sgen_get_remset ();
        D.21189 = D.21188->find_address_with_cards;
        D.21190 = D.21189 (start, cards, _objptr);
        if (D.21190 == 0) goto <D.21191>; else goto <D.21192>;
        <D.21191>:
        gc_debug_level.60 = gc_debug_level;
        D.21129 = gc_debug_level.60 >= 0;
        D.21130 = (long int) D.21129;
        D.21131 = __builtin_expect (D.21130, 0);
        if (D.21131 != 0) goto <D.21193>; else goto <D.21194>;
        <D.21193>:
        gc_debug_file.59 = gc_debug_file;
        D.21159 = *_objptr;
        _objptr.64 = (int) _objptr;
        start.62 = (int) start;
        D.21176 = _objptr.64 - start.62;
        D.21137 = MEM[(struct MonoObject *)start].vtable;
        D.21138 = D.21137->klass;
        D.21139 = D.21138->name_space;
        D.21137 = MEM[(struct MonoObject *)start].vtable;
        D.21138 = D.21137->klass;
        D.21140 = D.21138->name;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21159, D.21176, start, D.21139, D.21140);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.21194>:
        <D.21192>:
        <D.21187>:
        <D.21184>:
        <D.21181>:
        _objptr = _objptr + 4;
      }
      <D.20015>:
      if (_bmap != 0) goto <D.20014>; else goto <D.20016>;
      <D.20016>:
    }
    goto <D.20008>;
    <D.20017>:
    D.21195 = desc & 4294950912;
    if (D.21195 != 0) goto <D.21196>; else goto <D.21197>;
    <D.21196>:
    {
      int el_size;
      int etype;

      D.21198 = desc >> 3;
      D.21199 = (int) D.21198;
      el_size = D.21199 & 1023;
      desc.66 = (int) desc;
      etype = desc.66 & 49152;
      if (etype == 16384) goto <D.21201>; else goto <D.21202>;
      <D.21201>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.21203 = MEM[(struct MonoArray *)start].max_length;
        el_size.67 = (unsigned int) el_size;
        D.21205 = D.21203 * el_size.67;
        end_refs = p + D.21205;
        goto <D.20023>;
        <D.20022>:
        D.21206 = *p;
        if (D.21206 != 0B) goto <D.21207>; else goto <D.21208>;
        <D.21207>:
        D.21206 = *p;
        D.21209 = sgen_ptr_in_nursery (D.21206);
        if (D.21209 == 0) goto <D.21210>; else goto <D.21211>;
        <D.21210>:
        D.21206 = *p;
        D.21212 = is_major_or_los_object_marked (D.21206);
        if (D.21212 == 0) goto <D.21213>; else goto <D.21214>;
        <D.21213>:
        D.21215 = sgen_get_remset ();
        D.21216 = D.21215->find_address_with_cards;
        D.21217 = D.21216 (start, cards, p);
        if (D.21217 == 0) goto <D.21218>; else goto <D.21219>;
        <D.21218>:
        gc_debug_level.60 = gc_debug_level;
        D.21129 = gc_debug_level.60 >= 0;
        D.21130 = (long int) D.21129;
        D.21131 = __builtin_expect (D.21130, 0);
        if (D.21131 != 0) goto <D.21220>; else goto <D.21221>;
        <D.21220>:
        gc_debug_file.59 = gc_debug_file;
        D.21206 = *p;
        p.68 = (int) p;
        start.62 = (int) start;
        D.21223 = p.68 - start.62;
        D.21137 = MEM[(struct MonoObject *)start].vtable;
        D.21138 = D.21137->klass;
        D.21139 = D.21138->name_space;
        D.21137 = MEM[(struct MonoObject *)start].vtable;
        D.21138 = D.21137->klass;
        D.21140 = D.21138->name;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21206, D.21223, start, D.21139, D.21140);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.21221>:
        <D.21219>:
        <D.21214>:
        <D.21211>:
        <D.21208>:
        p = p + 4;
        <D.20023>:
        if (p < end_refs) goto <D.20022>; else goto <D.20024>;
        <D.20024>:
      }
      goto <D.21224>;
      <D.21202>:
      if (etype == 32768) goto <D.21225>; else goto <D.21226>;
      <D.21225>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.21109 = desc >> 16;
        D.21227 = (int) D.21109;
        offset = D.21227 & 255;
        D.21112 = desc >> 24;
        num_refs = (int) D.21112;
        e_start = start + 16;
        D.21203 = MEM[(struct MonoArray *)start].max_length;
        el_size.67 = (unsigned int) el_size;
        D.21205 = D.21203 * el_size.67;
        e_end = e_start + D.21205;
        goto <D.20035>;
        <D.20034>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.69 = (unsigned int) offset;
          D.21229 = offset.69 * 4;
          p = p + D.21229;
          i = 0;
          goto <D.20032>;
          <D.20031>:
          i.70 = (unsigned int) i;
          D.21231 = i.70 * 4;
          D.21232 = p + D.21231;
          D.21233 = *D.21232;
          if (D.21233 != 0B) goto <D.21234>; else goto <D.21235>;
          <D.21234>:
          i.70 = (unsigned int) i;
          D.21231 = i.70 * 4;
          D.21232 = p + D.21231;
          D.21233 = *D.21232;
          D.21236 = sgen_ptr_in_nursery (D.21233);
          if (D.21236 == 0) goto <D.21237>; else goto <D.21238>;
          <D.21237>:
          i.70 = (unsigned int) i;
          D.21231 = i.70 * 4;
          D.21232 = p + D.21231;
          D.21233 = *D.21232;
          D.21239 = is_major_or_los_object_marked (D.21233);
          if (D.21239 == 0) goto <D.21240>; else goto <D.21241>;
          <D.21240>:
          D.21242 = sgen_get_remset ();
          D.21243 = D.21242->find_address_with_cards;
          i.70 = (unsigned int) i;
          D.21231 = i.70 * 4;
          D.21244 = p + D.21231;
          D.21245 = D.21243 (start, cards, D.21244);
          if (D.21245 == 0) goto <D.21246>; else goto <D.21247>;
          <D.21246>:
          gc_debug_level.60 = gc_debug_level;
          D.21129 = gc_debug_level.60 >= 0;
          D.21130 = (long int) D.21129;
          D.21131 = __builtin_expect (D.21130, 0);
          if (D.21131 != 0) goto <D.21248>; else goto <D.21249>;
          <D.21248>:
          gc_debug_file.59 = gc_debug_file;
          i.70 = (unsigned int) i;
          D.21231 = i.70 * 4;
          D.21232 = p + D.21231;
          D.21233 = *D.21232;
          i.70 = (unsigned int) i;
          D.21231 = i.70 * 4;
          D.21244 = p + D.21231;
          D.21250 = (int) D.21244;
          start.62 = (int) start;
          D.21251 = D.21250 - start.62;
          D.21137 = MEM[(struct MonoObject *)start].vtable;
          D.21138 = D.21137->klass;
          D.21139 = D.21138->name_space;
          D.21137 = MEM[(struct MonoObject *)start].vtable;
          D.21138 = D.21137->klass;
          D.21140 = D.21138->name;
          fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21233, D.21251, start, D.21139, D.21140);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.21249>:
          <D.21247>:
          <D.21241>:
          <D.21238>:
          <D.21235>:
          i = i + 1;
          <D.20032>:
          if (i < num_refs) goto <D.20031>; else goto <D.20033>;
          <D.20033>:
          el_size.71 = (sizetype) el_size;
          e_start = e_start + el_size.71;
        }
        <D.20035>:
        if (e_start < e_end) goto <D.20034>; else goto <D.20036>;
        <D.20036>:
      }
      goto <D.21253>;
      <D.21226>:
      if (etype == 49152) goto <D.21254>; else goto <D.21255>;
      <D.21254>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.21203 = MEM[(struct MonoArray *)start].max_length;
        el_size.67 = (unsigned int) el_size;
        D.21205 = D.21203 * el_size.67;
        e_end = e_start + D.21205;
        goto <D.20045>;
        <D.20044>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.20042>;
          <D.20041>:
          D.21256 = _bmap & 1;
          if (D.21256 != 0) goto <D.21257>; else goto <D.21258>;
          <D.21257>:
          D.21259 = *p;
          if (D.21259 != 0B) goto <D.21260>; else goto <D.21261>;
          <D.21260>:
          D.21259 = *p;
          D.21262 = sgen_ptr_in_nursery (D.21259);
          if (D.21262 == 0) goto <D.21263>; else goto <D.21264>;
          <D.21263>:
          D.21259 = *p;
          D.21265 = is_major_or_los_object_marked (D.21259);
          if (D.21265 == 0) goto <D.21266>; else goto <D.21267>;
          <D.21266>:
          D.21268 = sgen_get_remset ();
          D.21269 = D.21268->find_address_with_cards;
          D.21270 = D.21269 (start, cards, p);
          if (D.21270 == 0) goto <D.21271>; else goto <D.21272>;
          <D.21271>:
          gc_debug_level.60 = gc_debug_level;
          D.21129 = gc_debug_level.60 >= 0;
          D.21130 = (long int) D.21129;
          D.21131 = __builtin_expect (D.21130, 0);
          if (D.21131 != 0) goto <D.21273>; else goto <D.21274>;
          <D.21273>:
          gc_debug_file.59 = gc_debug_file;
          D.21259 = *p;
          p.72 = (int) p;
          start.62 = (int) start;
          D.21276 = p.72 - start.62;
          D.21137 = MEM[(struct MonoObject *)start].vtable;
          D.21138 = D.21137->klass;
          D.21139 = D.21138->name_space;
          D.21137 = MEM[(struct MonoObject *)start].vtable;
          D.21138 = D.21137->klass;
          D.21140 = D.21138->name;
          fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21259, D.21276, start, D.21139, D.21140);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.21274>:
          <D.21272>:
          <D.21267>:
          <D.21264>:
          <D.21261>:
          <D.21258>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.20042>:
          if (_bmap != 0) goto <D.20041>; else goto <D.20043>;
          <D.20043>:
          el_size.71 = (sizetype) el_size;
          e_start = e_start + el_size.71;
        }
        <D.20045>:
        if (e_start < e_end) goto <D.20044>; else goto <D.20046>;
        <D.20046>:
      }
      <D.21255>:
      <D.21253>:
      <D.21224>:
    }
    <D.21197>:
    goto <D.20008>;
    <D.20047>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.20051>;
      <D.20050>:
      D.21277 = _bmap & 1;
      if (D.21277 != 0) goto <D.21278>; else goto <D.21279>;
      <D.21278>:
      D.21280 = *_objptr;
      if (D.21280 != 0B) goto <D.21281>; else goto <D.21282>;
      <D.21281>:
      D.21280 = *_objptr;
      D.21283 = sgen_ptr_in_nursery (D.21280);
      if (D.21283 == 0) goto <D.21284>; else goto <D.21285>;
      <D.21284>:
      D.21280 = *_objptr;
      D.21286 = is_major_or_los_object_marked (D.21280);
      if (D.21286 == 0) goto <D.21287>; else goto <D.21288>;
      <D.21287>:
      D.21289 = sgen_get_remset ();
      D.21290 = D.21289->find_address_with_cards;
      D.21291 = D.21290 (start, cards, _objptr);
      if (D.21291 == 0) goto <D.21292>; else goto <D.21293>;
      <D.21292>:
      gc_debug_level.60 = gc_debug_level;
      D.21129 = gc_debug_level.60 >= 0;
      D.21130 = (long int) D.21129;
      D.21131 = __builtin_expect (D.21130, 0);
      if (D.21131 != 0) goto <D.21294>; else goto <D.21295>;
      <D.21294>:
      gc_debug_file.59 = gc_debug_file;
      D.21280 = *_objptr;
      _objptr.73 = (int) _objptr;
      start.62 = (int) start;
      D.21297 = _objptr.73 - start.62;
      D.21137 = MEM[(struct MonoObject *)start].vtable;
      D.21138 = D.21137->klass;
      D.21139 = D.21138->name_space;
      D.21137 = MEM[(struct MonoObject *)start].vtable;
      D.21138 = D.21137->klass;
      D.21140 = D.21138->name;
      fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21280, D.21297, start, D.21139, D.21140);
      gc_debug_file.59 = gc_debug_file;
      fflush (gc_debug_file.59);
      <D.21295>:
      <D.21293>:
      <D.21288>:
      <D.21285>:
      <D.21282>:
      <D.21279>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20051>:
      if (_bmap != 0) goto <D.20050>; else goto <D.20052>;
      <D.20052>:
    }
    goto <D.20008>;
    <D.20053>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.21298 = *bitmap_data;
      D.21299 = D.21298 + 4294967295;
      bwords = (int) D.21299;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.21300>; else goto <D.21301>;
      <D.21300>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.21302 = myobj->vtable;
        D.21303 = D.21302->klass;
        D.21304 = D.21303->name_space;
        D.21302 = myobj->vtable;
        D.21303 = D.21302->klass;
        D.21305 = D.21303->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21304, D.21305);
      }
      <D.21301>:
      goto <D.20064>;
      <D.20063>:
      {
        gsize _bmap;

        bitmap_data.74 = bitmap_data;
        bitmap_data = bitmap_data.74 + 4;
        _bmap = *bitmap_data.74;
        _objptr = start_run;
        goto <D.20061>;
        <D.20060>:
        D.21307 = _bmap & 1;
        if (D.21307 != 0) goto <D.21308>; else goto <D.21309>;
        <D.21308>:
        D.21310 = *_objptr;
        if (D.21310 != 0B) goto <D.21311>; else goto <D.21312>;
        <D.21311>:
        D.21310 = *_objptr;
        D.21313 = sgen_ptr_in_nursery (D.21310);
        if (D.21313 == 0) goto <D.21314>; else goto <D.21315>;
        <D.21314>:
        D.21310 = *_objptr;
        D.21316 = is_major_or_los_object_marked (D.21310);
        if (D.21316 == 0) goto <D.21317>; else goto <D.21318>;
        <D.21317>:
        D.21319 = sgen_get_remset ();
        D.21320 = D.21319->find_address_with_cards;
        D.21321 = D.21320 (start, cards, _objptr);
        if (D.21321 == 0) goto <D.21322>; else goto <D.21323>;
        <D.21322>:
        gc_debug_level.60 = gc_debug_level;
        D.21129 = gc_debug_level.60 >= 0;
        D.21130 = (long int) D.21129;
        D.21131 = __builtin_expect (D.21130, 0);
        if (D.21131 != 0) goto <D.21324>; else goto <D.21325>;
        <D.21324>:
        gc_debug_file.59 = gc_debug_file;
        D.21310 = *_objptr;
        _objptr.75 = (int) _objptr;
        start.62 = (int) start;
        D.21327 = _objptr.75 - start.62;
        D.21137 = MEM[(struct MonoObject *)start].vtable;
        D.21138 = D.21137->klass;
        D.21139 = D.21138->name_space;
        D.21137 = MEM[(struct MonoObject *)start].vtable;
        D.21138 = D.21137->klass;
        D.21140 = D.21138->name;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21310, D.21327, start, D.21139, D.21140);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.21325>:
        <D.21323>:
        <D.21318>:
        <D.21315>:
        <D.21312>:
        <D.21309>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.20061>:
        if (_bmap != 0) goto <D.20060>; else goto <D.20062>;
        <D.20062>:
        start_run = start_run + 128;
      }
      <D.20064>:
      bwords.76 = bwords;
      bwords = bwords.76 + -1;
      if (bwords.76 > 0) goto <D.20063>; else goto <D.20065>;
      <D.20065>:
    }
    goto <D.20008>;
    <D.20066>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.21329 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.21329);
      mbitmap_data.77 = mbitmap_data;
      mbitmap_data = mbitmap_data.77 + 4;
      D.21331 = *mbitmap_data.77;
      D.21332 = D.21331 + 4294967295;
      mbwords = (int) D.21332;
      D.21333 = vt->klass;
      el_size = mono_array_element_size (D.21333);
      e_start = start + 16;
      D.21203 = MEM[(struct MonoArray *)start].max_length;
      el_size.78 = (unsigned int) el_size;
      D.21335 = D.21203 * el_size.78;
      e_end = e_start + D.21335;
      if (0 != 0) goto <D.21336>; else goto <D.21337>;
      <D.21336>:
      D.21329 = vt->desc;
      D.21333 = vt->klass;
      D.21338 = D.21333->name_space;
      D.21333 = vt->klass;
      D.21339 = D.21333->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.21329, D.21338, D.21339);
      <D.21337>:
      goto <D.20084>;
      <D.20083>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.79 = bitmap_data;
          bitmap_data = bitmap_data.79 + 4;
          _bmap = *bitmap_data.79;
          start_run = _objptr;
          goto <D.20078>;
          <D.20077>:
          D.21341 = _bmap & 1;
          if (D.21341 != 0) goto <D.21342>; else goto <D.21343>;
          <D.21342>:
          D.21344 = *_objptr;
          if (D.21344 != 0B) goto <D.21345>; else goto <D.21346>;
          <D.21345>:
          D.21344 = *_objptr;
          D.21347 = sgen_ptr_in_nursery (D.21344);
          if (D.21347 == 0) goto <D.21348>; else goto <D.21349>;
          <D.21348>:
          D.21344 = *_objptr;
          D.21350 = is_major_or_los_object_marked (D.21344);
          if (D.21350 == 0) goto <D.21351>; else goto <D.21352>;
          <D.21351>:
          D.21353 = sgen_get_remset ();
          D.21354 = D.21353->find_address_with_cards;
          D.21355 = D.21354 (start, cards, _objptr);
          if (D.21355 == 0) goto <D.21356>; else goto <D.21357>;
          <D.21356>:
          gc_debug_level.60 = gc_debug_level;
          D.21129 = gc_debug_level.60 >= 0;
          D.21130 = (long int) D.21129;
          D.21131 = __builtin_expect (D.21130, 0);
          if (D.21131 != 0) goto <D.21358>; else goto <D.21359>;
          <D.21358>:
          gc_debug_file.59 = gc_debug_file;
          D.21344 = *_objptr;
          _objptr.80 = (int) _objptr;
          start.62 = (int) start;
          D.21361 = _objptr.80 - start.62;
          D.21137 = MEM[(struct MonoObject *)start].vtable;
          D.21138 = D.21137->klass;
          D.21139 = D.21138->name_space;
          D.21137 = MEM[(struct MonoObject *)start].vtable;
          D.21138 = D.21137->klass;
          D.21140 = D.21138->name;
          fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.21344, D.21361, start, D.21139, D.21140);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.21359>:
          <D.21357>:
          <D.21352>:
          <D.21349>:
          <D.21346>:
          <D.21343>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.20078>:
          if (_bmap != 0) goto <D.20077>; else goto <D.20079>;
          <D.20079>:
          _objptr = start_run + 128;
        }
        <D.20081>:
        bwords.81 = bwords;
        bwords = bwords.81 + 4294967295;
        if (bwords.81 != 0) goto <D.20080>; else goto <D.20082>;
        <D.20082>:
        el_size.82 = (sizetype) el_size;
        e_start = e_start + el_size.82;
      }
      <D.20084>:
      if (e_start < e_end) goto <D.20083>; else goto <D.20085>;
      <D.20085>:
    }
    goto <D.20008>;
    <D.20086>:
    goto <D.20008>;
    <D.20087>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.20008>:
  }
}


is_major_or_los_object_marked (char * obj)
{
  unsigned int D.21366;
  gboolean D.21369;
  struct SgenMajorCollector * D.21370;
  gboolean (*<T3655>) (char *) D.21371;

  D.21366 = sgen_safe_object_get_size (obj);
  if (D.21366 > 8000) goto <D.21367>; else goto <D.21368>;
  <D.21367>:
  D.21369 = sgen_los_object_is_pinned (obj);
  return D.21369;
  <D.21368>:
  D.21370 = sgen_get_major_collector ();
  D.21371 = D.21370->is_object_live;
  D.21369 = D.21371 (obj);
  return D.21369;
}


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

  D.21373 = major_collector.iterate_objects;
  D.21373 (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)
{
  unsigned int D.21374;
  unsigned int D.21375;
  unsigned int D.21376;
  unsigned int D.21377;
  unsigned int D.21380;
  unsigned int D.21381;
  unsigned int D.21382;
  unsigned int D.21383;
  unsigned int D.21384;
  void * D.21385;
  unsigned int D.21388;
  unsigned int D.21389;
  int _objptr.83;
  int start.84;
  int D.21394;
  unsigned int D.21395;
  unsigned int D.21400;
  unsigned int _index.85;
  unsigned int D.21402;
  int D.21403;
  void * D.21404;
  unsigned int D.21407;
  unsigned int D.21408;
  int _objptr.86;
  int D.21412;
  unsigned int D.21413;
  unsigned int _index.87;
  unsigned int D.21415;
  int D.21416;
  unsigned int D.21421;
  unsigned int D.21422;
  unsigned int D.21425;
  int D.21426;
  int desc.88;
  unsigned int D.21430;
  unsigned int el_size.89;
  unsigned int D.21432;
  void * D.21433;
  unsigned int D.21436;
  unsigned int D.21437;
  int p.90;
  int D.21441;
  unsigned int D.21442;
  int D.21446;
  unsigned int offset.91;
  unsigned int D.21448;
  unsigned int i.92;
  unsigned int D.21450;
  void * * D.21451;
  void * D.21452;
  unsigned int D.21455;
  unsigned int D.21456;
  sizetype i.93;
  char * D.21460;
  int D.21461;
  int D.21462;
  unsigned int D.21463;
  sizetype el_size.94;
  unsigned int D.21468;
  void * D.21471;
  unsigned int D.21474;
  unsigned int D.21475;
  int p.95;
  int D.21479;
  unsigned int D.21480;
  unsigned int D.21481;
  void * D.21484;
  unsigned int D.21487;
  unsigned int D.21488;
  int _objptr.96;
  int D.21492;
  unsigned int D.21493;
  unsigned int D.21494;
  unsigned int D.21495;
  struct MonoVTable * D.21498;
  struct MonoClass * D.21499;
  const char * D.21500;
  const char * D.21501;
  gsize * bitmap_data.97;
  unsigned int D.21503;
  void * D.21506;
  unsigned int D.21509;
  unsigned int D.21510;
  int _objptr.98;
  int D.21514;
  unsigned int D.21515;
  int bwords.99;
  unsigned int D.21517;
  gsize * mbitmap_data.100;
  unsigned int D.21519;
  unsigned int D.21520;
  struct MonoClass * D.21521;
  unsigned int el_size.101;
  unsigned int D.21523;
  const char * D.21526;
  const char * D.21527;
  gsize * bitmap_data.102;
  unsigned int D.21529;
  void * D.21532;
  unsigned int D.21535;
  unsigned int D.21536;
  int _objptr.103;
  int D.21540;
  unsigned int D.21541;
  unsigned int bwords.104;
  sizetype el_size.105;

  {
    struct GCVTable * vt;
    mword desc;

    D.21374 = MEM[(mword *)start];
    D.21375 = D.21374 & 4294967292;
    vt = (struct GCVTable *) D.21375;
    desc = vt->desc;
    D.21376 = desc & 7;
    switch (D.21376) <default: <D.20193>, case 1: <D.20098>, case 2: <D.20107>, case 3: <D.20157>, case 4: <D.20117>, case 5: <D.20150>, case 6: <D.20171>, case 7: <D.20192>>
    <D.20098>:
    D.21377 = desc & 4294901760;
    if (D.21377 != 0) goto <D.21378>; else goto <D.21379>;
    <D.21378>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.21380 = desc >> 16;
      D.21381 = D.21380 & 255;
      D.21382 = D.21381 * 4;
      _objptr = _objptr + D.21382;
      D.21383 = desc >> 24;
      D.21384 = D.21383 * 4;
      _objptr_end = _objptr + D.21384;
      D.21385 = *_objptr;
      if (D.21385 != 0B) goto <D.21386>; else goto <D.21387>;
      <D.21386>:
      D.21385 = *_objptr;
      D.21388 = MEM[(mword *)D.21385];
      D.21389 = D.21388 & 4294967292;
      if (D.21389 == 0) goto <D.21390>; else goto <D.21391>;
      <D.21390>:
      _objptr.83 = (int) _objptr;
      start.84 = (int) start;
      D.21394 = _objptr.83 - start.84;
      D.21395 = sgen_safe_object_get_size (start);
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.21394, D.21395);
      <D.20101>:
      goto <D.20101>;
      <D.21391>:
      <D.21387>:
      _objptr = _objptr + 4;
      goto <D.20104>;
      <D.20103>:
      D.21385 = *_objptr;
      if (D.21385 != 0B) goto <D.21396>; else goto <D.21397>;
      <D.21396>:
      D.21385 = *_objptr;
      D.21388 = MEM[(mword *)D.21385];
      D.21389 = D.21388 & 4294967292;
      if (D.21389 == 0) goto <D.21398>; else goto <D.21399>;
      <D.21398>:
      _objptr.83 = (int) _objptr;
      start.84 = (int) start;
      D.21394 = _objptr.83 - start.84;
      D.21400 = sgen_safe_object_get_size (start);
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.21394, D.21400);
      <D.20102>:
      goto <D.20102>;
      <D.21399>:
      <D.21397>:
      _objptr = _objptr + 4;
      <D.20104>:
      if (_objptr < _objptr_end) goto <D.20103>; else goto <D.20105>;
      <D.20105>:
    }
    <D.21379>:
    goto <D.20106>;
    <D.20107>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.85 = (unsigned int) _index;
        D.21402 = _index.85 * 4;
        _objptr = _objptr + D.21402;
        D.21403 = _index + 1;
        _bmap = _bmap >> D.21403;
        D.21404 = *_objptr;
        if (D.21404 != 0B) goto <D.21405>; else goto <D.21406>;
        <D.21405>:
        D.21404 = *_objptr;
        D.21407 = MEM[(mword *)D.21404];
        D.21408 = D.21407 & 4294967292;
        if (D.21408 == 0) goto <D.21409>; else goto <D.21410>;
        <D.21409>:
        _objptr.86 = (int) _objptr;
        start.84 = (int) start;
        D.21412 = _objptr.86 - start.84;
        D.21413 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.21412, D.21413);
        <D.20111>:
        goto <D.20111>;
        <D.21410>:
        <D.21406>:
        _objptr = _objptr + 4;
      }
      goto <D.20115>;
      <D.20114>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.87 = (unsigned int) _index;
        D.21415 = _index.87 * 4;
        _objptr = _objptr + D.21415;
        D.21416 = _index + 1;
        _bmap = _bmap >> D.21416;
        D.21404 = *_objptr;
        if (D.21404 != 0B) goto <D.21417>; else goto <D.21418>;
        <D.21417>:
        D.21404 = *_objptr;
        D.21407 = MEM[(mword *)D.21404];
        D.21408 = D.21407 & 4294967292;
        if (D.21408 == 0) goto <D.21419>; else goto <D.21420>;
        <D.21419>:
        _objptr.86 = (int) _objptr;
        start.84 = (int) start;
        D.21412 = _objptr.86 - start.84;
        D.21421 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.21412, D.21421);
        <D.20113>:
        goto <D.20113>;
        <D.21420>:
        <D.21418>:
        _objptr = _objptr + 4;
      }
      <D.20115>:
      if (_bmap != 0) goto <D.20114>; else goto <D.20116>;
      <D.20116>:
    }
    goto <D.20106>;
    <D.20117>:
    D.21422 = desc & 4294950912;
    if (D.21422 != 0) goto <D.21423>; else goto <D.21424>;
    <D.21423>:
    {
      int el_size;
      int etype;

      D.21425 = desc >> 3;
      D.21426 = (int) D.21425;
      el_size = D.21426 & 1023;
      desc.88 = (int) desc;
      etype = desc.88 & 49152;
      if (etype == 16384) goto <D.21428>; else goto <D.21429>;
      <D.21428>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.21430 = MEM[(struct MonoArray *)start].max_length;
        el_size.89 = (unsigned int) el_size;
        D.21432 = D.21430 * el_size.89;
        end_refs = p + D.21432;
        goto <D.20124>;
        <D.20123>:
        D.21433 = *p;
        if (D.21433 != 0B) goto <D.21434>; else goto <D.21435>;
        <D.21434>:
        D.21433 = *p;
        D.21436 = MEM[(mword *)D.21433];
        D.21437 = D.21436 & 4294967292;
        if (D.21437 == 0) goto <D.21438>; else goto <D.21439>;
        <D.21438>:
        p.90 = (int) p;
        start.84 = (int) start;
        D.21441 = p.90 - start.84;
        D.21442 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.21441, D.21442);
        <D.20122>:
        goto <D.20122>;
        <D.21439>:
        <D.21435>:
        p = p + 4;
        <D.20124>:
        if (p < end_refs) goto <D.20123>; else goto <D.20125>;
        <D.20125>:
      }
      goto <D.21443>;
      <D.21429>:
      if (etype == 32768) goto <D.21444>; else goto <D.21445>;
      <D.21444>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.21380 = desc >> 16;
        D.21446 = (int) D.21380;
        offset = D.21446 & 255;
        D.21383 = desc >> 24;
        num_refs = (int) D.21383;
        e_start = start + 16;
        D.21430 = MEM[(struct MonoArray *)start].max_length;
        el_size.89 = (unsigned int) el_size;
        D.21432 = D.21430 * el_size.89;
        e_end = e_start + D.21432;
        goto <D.20137>;
        <D.20136>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.91 = (unsigned int) offset;
          D.21448 = offset.91 * 4;
          p = p + D.21448;
          i = 0;
          goto <D.20134>;
          <D.20133>:
          i.92 = (unsigned int) i;
          D.21450 = i.92 * 4;
          D.21451 = p + D.21450;
          D.21452 = *D.21451;
          if (D.21452 != 0B) goto <D.21453>; else goto <D.21454>;
          <D.21453>:
          i.92 = (unsigned int) i;
          D.21450 = i.92 * 4;
          D.21451 = p + D.21450;
          D.21452 = *D.21451;
          D.21455 = MEM[(mword *)D.21452];
          D.21456 = D.21455 & 4294967292;
          if (D.21456 == 0) goto <D.21457>; else goto <D.21458>;
          <D.21457>:
          i.93 = (sizetype) i;
          D.21460 = p + i.93;
          D.21461 = (int) D.21460;
          start.84 = (int) start;
          D.21462 = D.21461 - start.84;
          D.21463 = sgen_safe_object_get_size (start);
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.21462, D.21463);
          <D.20132>:
          goto <D.20132>;
          <D.21458>:
          <D.21454>:
          i = i + 1;
          <D.20134>:
          if (i < num_refs) goto <D.20133>; else goto <D.20135>;
          <D.20135>:
          el_size.94 = (sizetype) el_size;
          e_start = e_start + el_size.94;
        }
        <D.20137>:
        if (e_start < e_end) goto <D.20136>; else goto <D.20138>;
        <D.20138>:
      }
      goto <D.21465>;
      <D.21445>:
      if (etype == 49152) goto <D.21466>; else goto <D.21467>;
      <D.21466>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.21430 = MEM[(struct MonoArray *)start].max_length;
        el_size.89 = (unsigned int) el_size;
        D.21432 = D.21430 * el_size.89;
        e_end = e_start + D.21432;
        goto <D.20148>;
        <D.20147>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.20145>;
          <D.20144>:
          D.21468 = _bmap & 1;
          if (D.21468 != 0) goto <D.21469>; else goto <D.21470>;
          <D.21469>:
          D.21471 = *p;
          if (D.21471 != 0B) goto <D.21472>; else goto <D.21473>;
          <D.21472>:
          D.21471 = *p;
          D.21474 = MEM[(mword *)D.21471];
          D.21475 = D.21474 & 4294967292;
          if (D.21475 == 0) goto <D.21476>; else goto <D.21477>;
          <D.21476>:
          p.95 = (int) p;
          start.84 = (int) start;
          D.21479 = p.95 - start.84;
          D.21480 = sgen_safe_object_get_size (start);
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.21479, D.21480);
          <D.20143>:
          goto <D.20143>;
          <D.21477>:
          <D.21473>:
          <D.21470>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.20145>:
          if (_bmap != 0) goto <D.20144>; else goto <D.20146>;
          <D.20146>:
          el_size.94 = (sizetype) el_size;
          e_start = e_start + el_size.94;
        }
        <D.20148>:
        if (e_start < e_end) goto <D.20147>; else goto <D.20149>;
        <D.20149>:
      }
      <D.21467>:
      <D.21465>:
      <D.21443>:
    }
    <D.21424>:
    goto <D.20106>;
    <D.20150>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.20155>;
      <D.20154>:
      D.21481 = _bmap & 1;
      if (D.21481 != 0) goto <D.21482>; else goto <D.21483>;
      <D.21482>:
      D.21484 = *_objptr;
      if (D.21484 != 0B) goto <D.21485>; else goto <D.21486>;
      <D.21485>:
      D.21484 = *_objptr;
      D.21487 = MEM[(mword *)D.21484];
      D.21488 = D.21487 & 4294967292;
      if (D.21488 == 0) goto <D.21489>; else goto <D.21490>;
      <D.21489>:
      _objptr.96 = (int) _objptr;
      start.84 = (int) start;
      D.21492 = _objptr.96 - start.84;
      D.21493 = sgen_safe_object_get_size (start);
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.21492, D.21493);
      <D.20153>:
      goto <D.20153>;
      <D.21490>:
      <D.21486>:
      <D.21483>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20155>:
      if (_bmap != 0) goto <D.20154>; else goto <D.20156>;
      <D.20156>:
    }
    goto <D.20106>;
    <D.20157>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.21494 = *bitmap_data;
      D.21495 = D.21494 + 4294967295;
      bwords = (int) D.21495;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.21496>; else goto <D.21497>;
      <D.21496>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.21498 = myobj->vtable;
        D.21499 = D.21498->klass;
        D.21500 = D.21499->name_space;
        D.21498 = myobj->vtable;
        D.21499 = D.21498->klass;
        D.21501 = D.21499->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21500, D.21501);
      }
      <D.21497>:
      goto <D.20169>;
      <D.20168>:
      {
        gsize _bmap;

        bitmap_data.97 = bitmap_data;
        bitmap_data = bitmap_data.97 + 4;
        _bmap = *bitmap_data.97;
        _objptr = start_run;
        goto <D.20166>;
        <D.20165>:
        D.21503 = _bmap & 1;
        if (D.21503 != 0) goto <D.21504>; else goto <D.21505>;
        <D.21504>:
        D.21506 = *_objptr;
        if (D.21506 != 0B) goto <D.21507>; else goto <D.21508>;
        <D.21507>:
        D.21506 = *_objptr;
        D.21509 = MEM[(mword *)D.21506];
        D.21510 = D.21509 & 4294967292;
        if (D.21510 == 0) goto <D.21511>; else goto <D.21512>;
        <D.21511>:
        _objptr.98 = (int) _objptr;
        start.84 = (int) start;
        D.21514 = _objptr.98 - start.84;
        D.21515 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.21514, D.21515);
        <D.20164>:
        goto <D.20164>;
        <D.21512>:
        <D.21508>:
        <D.21505>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.20166>:
        if (_bmap != 0) goto <D.20165>; else goto <D.20167>;
        <D.20167>:
        start_run = start_run + 128;
      }
      <D.20169>:
      bwords.99 = bwords;
      bwords = bwords.99 + -1;
      if (bwords.99 > 0) goto <D.20168>; else goto <D.20170>;
      <D.20170>:
    }
    goto <D.20106>;
    <D.20171>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.21517 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.21517);
      mbitmap_data.100 = mbitmap_data;
      mbitmap_data = mbitmap_data.100 + 4;
      D.21519 = *mbitmap_data.100;
      D.21520 = D.21519 + 4294967295;
      mbwords = (int) D.21520;
      D.21521 = vt->klass;
      el_size = mono_array_element_size (D.21521);
      e_start = start + 16;
      D.21430 = MEM[(struct MonoArray *)start].max_length;
      el_size.101 = (unsigned int) el_size;
      D.21523 = D.21430 * el_size.101;
      e_end = e_start + D.21523;
      if (0 != 0) goto <D.21524>; else goto <D.21525>;
      <D.21524>:
      D.21517 = vt->desc;
      D.21521 = vt->klass;
      D.21526 = D.21521->name_space;
      D.21521 = vt->klass;
      D.21527 = D.21521->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.21517, D.21526, D.21527);
      <D.21525>:
      goto <D.20190>;
      <D.20189>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.102 = bitmap_data;
          bitmap_data = bitmap_data.102 + 4;
          _bmap = *bitmap_data.102;
          start_run = _objptr;
          goto <D.20184>;
          <D.20183>:
          D.21529 = _bmap & 1;
          if (D.21529 != 0) goto <D.21530>; else goto <D.21531>;
          <D.21530>:
          D.21532 = *_objptr;
          if (D.21532 != 0B) goto <D.21533>; else goto <D.21534>;
          <D.21533>:
          D.21532 = *_objptr;
          D.21535 = MEM[(mword *)D.21532];
          D.21536 = D.21535 & 4294967292;
          if (D.21536 == 0) goto <D.21537>; else goto <D.21538>;
          <D.21537>:
          _objptr.103 = (int) _objptr;
          start.84 = (int) start;
          D.21540 = _objptr.103 - start.84;
          D.21541 = sgen_safe_object_get_size (start);
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.21540, D.21541);
          <D.20182>:
          goto <D.20182>;
          <D.21538>:
          <D.21534>:
          <D.21531>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.20184>:
          if (_bmap != 0) goto <D.20183>; else goto <D.20185>;
          <D.20185>:
          _objptr = start_run + 128;
        }
        <D.20187>:
        bwords.104 = bwords;
        bwords = bwords.104 + 4294967295;
        if (bwords.104 != 0) goto <D.20186>; else goto <D.20188>;
        <D.20188>:
        el_size.105 = (sizetype) el_size;
        e_start = e_start + el_size.105;
      }
      <D.20190>:
      if (e_start < e_end) goto <D.20189>; else goto <D.20191>;
      <D.20191>:
    }
    goto <D.20106>;
    <D.20192>:
    goto <D.20106>;
    <D.20193>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.20106>:
  }
}


check_object (char * start)
{
  unsigned int D.21547;
  unsigned int D.21548;
  unsigned int D.21549;
  unsigned int D.21550;
  unsigned int D.21553;
  unsigned int D.21554;
  unsigned int D.21555;
  unsigned int D.21556;
  unsigned int D.21557;
  void * D.21558;
  const char * D.21561;
  _Bool D.21562;
  long int D.21563;
  long int D.21564;
  const char * D.21569;
  _Bool D.21570;
  long int D.21571;
  long int D.21572;
  unsigned int _index.106;
  unsigned int D.21576;
  int D.21577;
  void * D.21578;
  const char * D.21581;
  _Bool D.21582;
  long int D.21583;
  long int D.21584;
  unsigned int _index.107;
  unsigned int D.21588;
  int D.21589;
  const char * D.21592;
  _Bool D.21593;
  long int D.21594;
  long int D.21595;
  unsigned int D.21598;
  unsigned int D.21601;
  int D.21602;
  int desc.108;
  unsigned int D.21606;
  unsigned int el_size.109;
  unsigned int D.21608;
  void * D.21609;
  const char * D.21612;
  _Bool D.21613;
  long int D.21614;
  long int D.21615;
  int D.21621;
  unsigned int offset.110;
  unsigned int D.21623;
  unsigned int i.111;
  unsigned int D.21625;
  void * * D.21626;
  void * D.21627;
  const char * D.21630;
  _Bool D.21631;
  long int D.21632;
  long int D.21633;
  sizetype el_size.112;
  unsigned int D.21640;
  void * D.21643;
  const char * D.21646;
  _Bool D.21647;
  long int D.21648;
  long int D.21649;
  unsigned int D.21652;
  void * D.21655;
  const char * D.21658;
  _Bool D.21659;
  long int D.21660;
  long int D.21661;
  unsigned int D.21664;
  unsigned int D.21665;
  struct MonoVTable * D.21668;
  struct MonoClass * D.21669;
  const char * D.21670;
  const char * D.21671;
  gsize * bitmap_data.113;
  unsigned int D.21673;
  void * D.21676;
  const char * D.21679;
  _Bool D.21680;
  long int D.21681;
  long int D.21682;
  int bwords.114;
  unsigned int D.21686;
  gsize * mbitmap_data.115;
  unsigned int D.21688;
  unsigned int D.21689;
  struct MonoClass * D.21690;
  unsigned int el_size.116;
  unsigned int D.21692;
  const char * D.21695;
  const char * D.21696;
  gsize * bitmap_data.117;
  unsigned int D.21698;
  void * D.21701;
  const char * D.21704;
  _Bool D.21705;
  long int D.21706;
  long int D.21707;
  unsigned int bwords.118;
  sizetype el_size.119;

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

    D.21547 = MEM[(mword *)start];
    D.21548 = D.21547 & 4294967292;
    vt = (struct GCVTable *) D.21548;
    desc = vt->desc;
    D.21549 = desc & 7;
    switch (D.21549) <default: <D.20287>, case 1: <D.20202>, case 2: <D.20209>, case 3: <D.20253>, case 4: <D.20217>, case 5: <D.20247>, case 6: <D.20266>, case 7: <D.20286>>
    <D.20202>:
    D.21550 = desc & 4294901760;
    if (D.21550 != 0) goto <D.21551>; else goto <D.21552>;
    <D.21551>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.21553 = desc >> 16;
      D.21554 = D.21553 & 255;
      D.21555 = D.21554 * 4;
      _objptr = _objptr + D.21555;
      D.21556 = desc >> 24;
      D.21557 = D.21556 * 4;
      _objptr_end = _objptr + D.21557;
      D.21558 = *_objptr;
      if (D.21558 != 0B) goto <D.21559>; else goto <D.21560>;
      <D.21559>:
      D.21558 = *_objptr;
      D.21561 = sgen_safe_name (D.21558);
      D.21562 = D.21561 == 0B;
      D.21563 = (long int) D.21562;
      D.21564 = __builtin_expect (D.21563, 0);
      if (D.21564 != 0) goto <D.21565>; else goto <D.21566>;
      <D.21565>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_safe_name (*(_objptr)) != NULL");
      <D.21566>:
      <D.21560>:
      _objptr = _objptr + 4;
      goto <D.20206>;
      <D.20205>:
      D.21558 = *_objptr;
      if (D.21558 != 0B) goto <D.21567>; else goto <D.21568>;
      <D.21567>:
      D.21558 = *_objptr;
      D.21569 = sgen_safe_name (D.21558);
      D.21570 = D.21569 == 0B;
      D.21571 = (long int) D.21570;
      D.21572 = __builtin_expect (D.21571, 0);
      if (D.21572 != 0) goto <D.21573>; else goto <D.21574>;
      <D.21573>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_safe_name (*(_objptr)) != NULL");
      <D.21574>:
      <D.21568>:
      _objptr = _objptr + 4;
      <D.20206>:
      if (_objptr < _objptr_end) goto <D.20205>; else goto <D.20207>;
      <D.20207>:
    }
    <D.21552>:
    goto <D.20208>;
    <D.20209>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.106 = (unsigned int) _index;
        D.21576 = _index.106 * 4;
        _objptr = _objptr + D.21576;
        D.21577 = _index + 1;
        _bmap = _bmap >> D.21577;
        D.21578 = *_objptr;
        if (D.21578 != 0B) goto <D.21579>; else goto <D.21580>;
        <D.21579>:
        D.21578 = *_objptr;
        D.21581 = sgen_safe_name (D.21578);
        D.21582 = D.21581 == 0B;
        D.21583 = (long int) D.21582;
        D.21584 = __builtin_expect (D.21583, 0);
        if (D.21584 != 0) goto <D.21585>; else goto <D.21586>;
        <D.21585>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_safe_name (*(_objptr)) != NULL");
        <D.21586>:
        <D.21580>:
        _objptr = _objptr + 4;
      }
      goto <D.20215>;
      <D.20214>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.107 = (unsigned int) _index;
        D.21588 = _index.107 * 4;
        _objptr = _objptr + D.21588;
        D.21589 = _index + 1;
        _bmap = _bmap >> D.21589;
        D.21578 = *_objptr;
        if (D.21578 != 0B) goto <D.21590>; else goto <D.21591>;
        <D.21590>:
        D.21578 = *_objptr;
        D.21592 = sgen_safe_name (D.21578);
        D.21593 = D.21592 == 0B;
        D.21594 = (long int) D.21593;
        D.21595 = __builtin_expect (D.21594, 0);
        if (D.21595 != 0) goto <D.21596>; else goto <D.21597>;
        <D.21596>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_safe_name (*(_objptr)) != NULL");
        <D.21597>:
        <D.21591>:
        _objptr = _objptr + 4;
      }
      <D.20215>:
      if (_bmap != 0) goto <D.20214>; else goto <D.20216>;
      <D.20216>:
    }
    goto <D.20208>;
    <D.20217>:
    D.21598 = desc & 4294950912;
    if (D.21598 != 0) goto <D.21599>; else goto <D.21600>;
    <D.21599>:
    {
      int el_size;
      int etype;

      D.21601 = desc >> 3;
      D.21602 = (int) D.21601;
      el_size = D.21602 & 1023;
      desc.108 = (int) desc;
      etype = desc.108 & 49152;
      if (etype == 16384) goto <D.21604>; else goto <D.21605>;
      <D.21604>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.21606 = MEM[(struct MonoArray *)start].max_length;
        el_size.109 = (unsigned int) el_size;
        D.21608 = D.21606 * el_size.109;
        end_refs = p + D.21608;
        goto <D.20223>;
        <D.20222>:
        D.21609 = *p;
        if (D.21609 != 0B) goto <D.21610>; else goto <D.21611>;
        <D.21610>:
        D.21609 = *p;
        D.21612 = sgen_safe_name (D.21609);
        D.21613 = D.21612 == 0B;
        D.21614 = (long int) D.21613;
        D.21615 = __builtin_expect (D.21614, 0);
        if (D.21615 != 0) goto <D.21616>; else goto <D.21617>;
        <D.21616>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p)) != NULL");
        <D.21617>:
        <D.21611>:
        p = p + 4;
        <D.20223>:
        if (p < end_refs) goto <D.20222>; else goto <D.20224>;
        <D.20224>:
      }
      goto <D.21618>;
      <D.21605>:
      if (etype == 32768) goto <D.21619>; else goto <D.21620>;
      <D.21619>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.21553 = desc >> 16;
        D.21621 = (int) D.21553;
        offset = D.21621 & 255;
        D.21556 = desc >> 24;
        num_refs = (int) D.21556;
        e_start = start + 16;
        D.21606 = MEM[(struct MonoArray *)start].max_length;
        el_size.109 = (unsigned int) el_size;
        D.21608 = D.21606 * el_size.109;
        e_end = e_start + D.21608;
        goto <D.20235>;
        <D.20234>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.110 = (unsigned int) offset;
          D.21623 = offset.110 * 4;
          p = p + D.21623;
          i = 0;
          goto <D.20232>;
          <D.20231>:
          i.111 = (unsigned int) i;
          D.21625 = i.111 * 4;
          D.21626 = p + D.21625;
          D.21627 = *D.21626;
          if (D.21627 != 0B) goto <D.21628>; else goto <D.21629>;
          <D.21628>:
          i.111 = (unsigned int) i;
          D.21625 = i.111 * 4;
          D.21626 = p + D.21625;
          D.21627 = *D.21626;
          D.21630 = sgen_safe_name (D.21627);
          D.21631 = D.21630 == 0B;
          D.21632 = (long int) D.21631;
          D.21633 = __builtin_expect (D.21632, 0);
          if (D.21633 != 0) goto <D.21634>; else goto <D.21635>;
          <D.21634>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p + i)) != NULL");
          <D.21635>:
          <D.21629>:
          i = i + 1;
          <D.20232>:
          if (i < num_refs) goto <D.20231>; else goto <D.20233>;
          <D.20233>:
          el_size.112 = (sizetype) el_size;
          e_start = e_start + el_size.112;
        }
        <D.20235>:
        if (e_start < e_end) goto <D.20234>; else goto <D.20236>;
        <D.20236>:
      }
      goto <D.21637>;
      <D.21620>:
      if (etype == 49152) goto <D.21638>; else goto <D.21639>;
      <D.21638>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.21606 = MEM[(struct MonoArray *)start].max_length;
        el_size.109 = (unsigned int) el_size;
        D.21608 = D.21606 * el_size.109;
        e_end = e_start + D.21608;
        goto <D.20245>;
        <D.20244>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.20242>;
          <D.20241>:
          D.21640 = _bmap & 1;
          if (D.21640 != 0) goto <D.21641>; else goto <D.21642>;
          <D.21641>:
          D.21643 = *p;
          if (D.21643 != 0B) goto <D.21644>; else goto <D.21645>;
          <D.21644>:
          D.21643 = *p;
          D.21646 = sgen_safe_name (D.21643);
          D.21647 = D.21646 == 0B;
          D.21648 = (long int) D.21647;
          D.21649 = __builtin_expect (D.21648, 0);
          if (D.21649 != 0) goto <D.21650>; else goto <D.21651>;
          <D.21650>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p)) != NULL");
          <D.21651>:
          <D.21645>:
          <D.21642>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.20242>:
          if (_bmap != 0) goto <D.20241>; else goto <D.20243>;
          <D.20243>:
          el_size.112 = (sizetype) el_size;
          e_start = e_start + el_size.112;
        }
        <D.20245>:
        if (e_start < e_end) goto <D.20244>; else goto <D.20246>;
        <D.20246>:
      }
      <D.21639>:
      <D.21637>:
      <D.21618>:
    }
    <D.21600>:
    goto <D.20208>;
    <D.20247>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.20251>;
      <D.20250>:
      D.21652 = _bmap & 1;
      if (D.21652 != 0) goto <D.21653>; else goto <D.21654>;
      <D.21653>:
      D.21655 = *_objptr;
      if (D.21655 != 0B) goto <D.21656>; else goto <D.21657>;
      <D.21656>:
      D.21655 = *_objptr;
      D.21658 = sgen_safe_name (D.21655);
      D.21659 = D.21658 == 0B;
      D.21660 = (long int) D.21659;
      D.21661 = __builtin_expect (D.21660, 0);
      if (D.21661 != 0) goto <D.21662>; else goto <D.21663>;
      <D.21662>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "sgen_safe_name (*(_objptr)) != NULL");
      <D.21663>:
      <D.21657>:
      <D.21654>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20251>:
      if (_bmap != 0) goto <D.20250>; else goto <D.20252>;
      <D.20252>:
    }
    goto <D.20208>;
    <D.20253>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.21664 = *bitmap_data;
      D.21665 = D.21664 + 4294967295;
      bwords = (int) D.21665;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.21666>; else goto <D.21667>;
      <D.21666>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.21668 = myobj->vtable;
        D.21669 = D.21668->klass;
        D.21670 = D.21669->name_space;
        D.21668 = myobj->vtable;
        D.21669 = D.21668->klass;
        D.21671 = D.21669->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21670, D.21671);
      }
      <D.21667>:
      goto <D.20264>;
      <D.20263>:
      {
        gsize _bmap;

        bitmap_data.113 = bitmap_data;
        bitmap_data = bitmap_data.113 + 4;
        _bmap = *bitmap_data.113;
        _objptr = start_run;
        goto <D.20261>;
        <D.20260>:
        D.21673 = _bmap & 1;
        if (D.21673 != 0) goto <D.21674>; else goto <D.21675>;
        <D.21674>:
        D.21676 = *_objptr;
        if (D.21676 != 0B) goto <D.21677>; else goto <D.21678>;
        <D.21677>:
        D.21676 = *_objptr;
        D.21679 = sgen_safe_name (D.21676);
        D.21680 = D.21679 == 0B;
        D.21681 = (long int) D.21680;
        D.21682 = __builtin_expect (D.21681, 0);
        if (D.21682 != 0) goto <D.21683>; else goto <D.21684>;
        <D.21683>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "sgen_safe_name (*(_objptr)) != NULL");
        <D.21684>:
        <D.21678>:
        <D.21675>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.20261>:
        if (_bmap != 0) goto <D.20260>; else goto <D.20262>;
        <D.20262>:
        start_run = start_run + 128;
      }
      <D.20264>:
      bwords.114 = bwords;
      bwords = bwords.114 + -1;
      if (bwords.114 > 0) goto <D.20263>; else goto <D.20265>;
      <D.20265>:
    }
    goto <D.20208>;
    <D.20266>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.21686 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.21686);
      mbitmap_data.115 = mbitmap_data;
      mbitmap_data = mbitmap_data.115 + 4;
      D.21688 = *mbitmap_data.115;
      D.21689 = D.21688 + 4294967295;
      mbwords = (int) D.21689;
      D.21690 = vt->klass;
      el_size = mono_array_element_size (D.21690);
      e_start = start + 16;
      D.21606 = MEM[(struct MonoArray *)start].max_length;
      el_size.116 = (unsigned int) el_size;
      D.21692 = D.21606 * el_size.116;
      e_end = e_start + D.21692;
      if (0 != 0) goto <D.21693>; else goto <D.21694>;
      <D.21693>:
      D.21686 = vt->desc;
      D.21690 = vt->klass;
      D.21695 = D.21690->name_space;
      D.21690 = vt->klass;
      D.21696 = D.21690->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.21686, D.21695, D.21696);
      <D.21694>:
      goto <D.20284>;
      <D.20283>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.117 = bitmap_data;
          bitmap_data = bitmap_data.117 + 4;
          _bmap = *bitmap_data.117;
          start_run = _objptr;
          goto <D.20278>;
          <D.20277>:
          D.21698 = _bmap & 1;
          if (D.21698 != 0) goto <D.21699>; else goto <D.21700>;
          <D.21699>:
          D.21701 = *_objptr;
          if (D.21701 != 0B) goto <D.21702>; else goto <D.21703>;
          <D.21702>:
          D.21701 = *_objptr;
          D.21704 = sgen_safe_name (D.21701);
          D.21705 = D.21704 == 0B;
          D.21706 = (long int) D.21705;
          D.21707 = __builtin_expect (D.21706, 0);
          if (D.21707 != 0) goto <D.21708>; else goto <D.21709>;
          <D.21708>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "sgen_safe_name (*(_objptr)) != NULL");
          <D.21709>:
          <D.21703>:
          <D.21700>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.20278>:
          if (_bmap != 0) goto <D.20277>; else goto <D.20279>;
          <D.20279>:
          _objptr = start_run + 128;
        }
        <D.20281>:
        bwords.118 = bwords;
        bwords = bwords.118 + 4294967295;
        if (bwords.118 != 0) goto <D.20280>; else goto <D.20282>;
        <D.20282>:
        el_size.119 = (sizetype) el_size;
        e_start = e_start + el_size.119;
      }
      <D.20284>:
      if (e_start < e_end) goto <D.20283>; else goto <D.20285>;
      <D.20285>:
    }
    goto <D.20208>;
    <D.20286>:
    goto <D.20208>;
    <D.20287>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.20208>:
  }
}


sgen_check_whole_heap (gboolean allow_missing_pinned)
{
  struct GCMemSection * nursery_section.120;
  char * D.21715;
  char * D.21716;
  void * allow_missing_pinned.121;
  void (*<T36af>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.21718;
  int broken_heap.122;
  _Bool D.21720;
  long int D.21721;
  long int D.21722;

  setup_valid_nursery_objects ();
  broken_heap = 0;
  nursery_section.120 = nursery_section;
  D.21715 = nursery_section.120->data;
  nursery_section.120 = nursery_section;
  D.21716 = nursery_section.120->end_data;
  allow_missing_pinned.121 = (void *) allow_missing_pinned;
  sgen_scan_area_with_callback (D.21715, D.21716, verify_object_pointers_callback, allow_missing_pinned.121, 0);
  D.21718 = major_collector.iterate_objects;
  allow_missing_pinned.121 = (void *) allow_missing_pinned;
  D.21718 (1, 1, verify_object_pointers_callback, allow_missing_pinned.121);
  allow_missing_pinned.121 = (void *) allow_missing_pinned;
  sgen_los_iterate_objects (verify_object_pointers_callback, allow_missing_pinned.121);
  broken_heap.122 = broken_heap;
  D.21720 = broken_heap.122 != 0;
  D.21721 = (long int) D.21720;
  D.21722 = __builtin_expect (D.21721, 0);
  if (D.21722 != 0) goto <D.21723>; else goto <D.21724>;
  <D.21723>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 445, "!broken_heap");
  <D.21724>:
}


verify_object_pointers_callback (char * start, size_t size, void * data)
{
  unsigned int D.21725;
  unsigned int D.21726;
  unsigned int D.21727;
  unsigned int D.21728;
  unsigned int D.21731;
  unsigned int D.21732;
  unsigned int D.21733;
  unsigned int D.21734;
  unsigned int D.21735;
  char * D.21736;
  int D.21739;
  int D.21743;
  void * D.21746;
  int D.21747;
  struct SgenRemeberedSet * D.21752;
  gboolean (*<T3655>) (char *) D.21753;
  int D.21754;
  int D.21757;
  unsigned int D.21761;
  unsigned int D.21762;
  int D.21765;
  int D.21769;
  int D.21772;
  struct SgenRemeberedSet * D.21777;
  gboolean (*<T3655>) (char *) D.21778;
  int D.21779;
  int D.21782;
  unsigned int _index.123;
  unsigned int D.21787;
  int D.21788;
  char * D.21789;
  int D.21792;
  int D.21796;
  void * D.21799;
  int D.21800;
  struct SgenRemeberedSet * D.21805;
  gboolean (*<T3655>) (char *) D.21806;
  int D.21807;
  int D.21810;
  unsigned int D.21814;
  unsigned int D.21815;
  unsigned int _index.124;
  unsigned int D.21817;
  int D.21818;
  int D.21821;
  int D.21825;
  int D.21828;
  struct SgenRemeberedSet * D.21833;
  gboolean (*<T3655>) (char *) D.21834;
  int D.21835;
  int D.21838;
  unsigned int D.21842;
  unsigned int D.21845;
  int D.21846;
  int desc.125;
  unsigned int D.21850;
  unsigned int el_size.126;
  unsigned int D.21852;
  char * D.21853;
  int D.21856;
  int D.21860;
  void * D.21863;
  int D.21864;
  struct SgenRemeberedSet * D.21869;
  gboolean (*<T3655>) (char *) D.21870;
  int D.21871;
  int D.21874;
  unsigned int D.21878;
  unsigned int D.21879;
  int D.21883;
  unsigned int offset.127;
  unsigned int D.21885;
  char * D.21886;
  sizetype i.128;
  char * D.21888;
  int D.21891;
  unsigned int i.129;
  unsigned int D.21895;
  char * * D.21896;
  int D.21898;
  void * D.21901;
  void * D.21902;
  int D.21903;
  struct SgenRemeberedSet * D.21908;
  gboolean (*<T3655>) (char *) D.21909;
  char * D.21910;
  int D.21911;
  void * * D.21914;
  void * D.21915;
  int D.21916;
  unsigned int D.21920;
  unsigned int D.21921;
  sizetype el_size.130;
  unsigned int D.21926;
  char * D.21929;
  int D.21932;
  int D.21936;
  void * D.21939;
  int D.21940;
  struct SgenRemeberedSet * D.21945;
  gboolean (*<T3655>) (char *) D.21946;
  int D.21947;
  int D.21950;
  unsigned int D.21954;
  unsigned int D.21955;
  unsigned int D.21956;
  char * D.21959;
  int D.21962;
  int D.21966;
  void * D.21969;
  int D.21970;
  struct SgenRemeberedSet * D.21975;
  gboolean (*<T3655>) (char *) D.21976;
  int D.21977;
  int D.21980;
  unsigned int D.21984;
  unsigned int D.21985;
  unsigned int D.21986;
  unsigned int D.21987;
  struct MonoVTable * D.21990;
  struct MonoClass * D.21991;
  const char * D.21992;
  const char * D.21993;
  gsize * bitmap_data.131;
  unsigned int D.21995;
  char * D.21998;
  int D.22001;
  int D.22005;
  void * D.22008;
  int D.22009;
  struct SgenRemeberedSet * D.22014;
  gboolean (*<T3655>) (char *) D.22015;
  int D.22016;
  int D.22019;
  unsigned int D.22023;
  unsigned int D.22024;
  int bwords.132;
  unsigned int D.22026;
  gsize * mbitmap_data.133;
  unsigned int D.22028;
  unsigned int D.22029;
  struct MonoClass * D.22030;
  unsigned int el_size.134;
  unsigned int D.22032;
  const char * D.22035;
  const char * D.22036;
  gsize * bitmap_data.135;
  unsigned int D.22038;
  char * D.22041;
  int D.22044;
  int D.22048;
  void * D.22051;
  int D.22052;
  struct SgenRemeberedSet * D.22057;
  gboolean (*<T3655>) (char *) D.22058;
  int D.22059;
  int D.22062;
  unsigned int D.22066;
  unsigned int D.22067;
  unsigned int bwords.136;
  sizetype el_size.137;
  gboolean allow_missing_pinned;

  allow_missing_pinned = (gboolean) data;
  {
    struct GCVTable * vt;
    mword desc;

    D.21725 = MEM[(mword *)start];
    D.21726 = D.21725 & 4294967292;
    vt = (struct GCVTable *) D.21726;
    desc = vt->desc;
    D.21727 = desc & 7;
    switch (D.21727) <default: <D.20425>, case 1: <D.20340>, case 2: <D.20347>, case 3: <D.20391>, case 4: <D.20355>, case 5: <D.20385>, case 6: <D.20404>, case 7: <D.20424>>
    <D.20340>:
    D.21728 = desc & 4294901760;
    if (D.21728 != 0) goto <D.21729>; else goto <D.21730>;
    <D.21729>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.21731 = desc >> 16;
      D.21732 = D.21731 & 255;
      D.21733 = D.21732 * 4;
      _objptr = _objptr + D.21733;
      D.21734 = desc >> 24;
      D.21735 = D.21734 * 4;
      _objptr_end = _objptr + D.21735;
      D.21736 = MEM[(char * *)_objptr];
      if (D.21736 != 0B) goto <D.21737>; else goto <D.21738>;
      <D.21737>:
      D.21736 = MEM[(char * *)_objptr];
      D.21739 = is_valid_object_pointer (D.21736);
      if (D.21739 == 0) goto <D.21740>; else goto <D.21741>;
      <D.21740>:
      bad_pointer_spew (start, _objptr);
      goto <D.21742>;
      <D.21741>:
      D.21743 = sgen_ptr_in_nursery (start);
      if (D.21743 == 0) goto <D.21744>; else goto <D.21745>;
      <D.21744>:
      D.21746 = *_objptr;
      D.21747 = sgen_ptr_in_nursery (D.21746);
      if (D.21747 != 0) goto <D.21748>; else goto <D.21749>;
      <D.21748>:
      D.21752 = sgen_get_remset ();
      D.21753 = D.21752->find_address;
      D.21754 = D.21753 (_objptr);
      if (D.21754 == 0) goto <D.21755>; else goto <D.21756>;
      <D.21755>:
      D.21746 = *_objptr;
      D.21757 = sgen_cement_lookup (D.21746);
      if (D.21757 == 0) goto <D.21758>; else goto <D.21759>;
      <D.21758>:
      if (allow_missing_pinned == 0) goto <D.21750>; else goto <D.21760>;
      <D.21760>:
      D.21746 = *_objptr;
      D.21761 = MEM[(mword *)D.21746];
      D.21762 = D.21761 & 2;
      if (D.21762 == 0) goto <D.21750>; else goto <D.21751>;
      <D.21750>:
      missing_remset_spew (start, _objptr);
      <D.21751>:
      <D.21759>:
      <D.21756>:
      <D.21749>:
      <D.21745>:
      <D.21742>:
      <D.21738>:
      _objptr = _objptr + 4;
      goto <D.20344>;
      <D.20343>:
      D.21736 = MEM[(char * *)_objptr];
      if (D.21736 != 0B) goto <D.21763>; else goto <D.21764>;
      <D.21763>:
      D.21736 = MEM[(char * *)_objptr];
      D.21765 = is_valid_object_pointer (D.21736);
      if (D.21765 == 0) goto <D.21766>; else goto <D.21767>;
      <D.21766>:
      bad_pointer_spew (start, _objptr);
      goto <D.21768>;
      <D.21767>:
      D.21769 = sgen_ptr_in_nursery (start);
      if (D.21769 == 0) goto <D.21770>; else goto <D.21771>;
      <D.21770>:
      D.21746 = *_objptr;
      D.21772 = sgen_ptr_in_nursery (D.21746);
      if (D.21772 != 0) goto <D.21773>; else goto <D.21774>;
      <D.21773>:
      D.21777 = sgen_get_remset ();
      D.21778 = D.21777->find_address;
      D.21779 = D.21778 (_objptr);
      if (D.21779 == 0) goto <D.21780>; else goto <D.21781>;
      <D.21780>:
      D.21746 = *_objptr;
      D.21782 = sgen_cement_lookup (D.21746);
      if (D.21782 == 0) goto <D.21783>; else goto <D.21784>;
      <D.21783>:
      if (allow_missing_pinned == 0) goto <D.21775>; else goto <D.21785>;
      <D.21785>:
      D.21746 = *_objptr;
      D.21761 = MEM[(mword *)D.21746];
      D.21762 = D.21761 & 2;
      if (D.21762 == 0) goto <D.21775>; else goto <D.21776>;
      <D.21775>:
      missing_remset_spew (start, _objptr);
      <D.21776>:
      <D.21784>:
      <D.21781>:
      <D.21774>:
      <D.21771>:
      <D.21768>:
      <D.21764>:
      _objptr = _objptr + 4;
      <D.20344>:
      if (_objptr < _objptr_end) goto <D.20343>; else goto <D.20345>;
      <D.20345>:
    }
    <D.21730>:
    goto <D.20346>;
    <D.20347>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.123 = (unsigned int) _index;
        D.21787 = _index.123 * 4;
        _objptr = _objptr + D.21787;
        D.21788 = _index + 1;
        _bmap = _bmap >> D.21788;
        D.21789 = MEM[(char * *)_objptr];
        if (D.21789 != 0B) goto <D.21790>; else goto <D.21791>;
        <D.21790>:
        D.21789 = MEM[(char * *)_objptr];
        D.21792 = is_valid_object_pointer (D.21789);
        if (D.21792 == 0) goto <D.21793>; else goto <D.21794>;
        <D.21793>:
        bad_pointer_spew (start, _objptr);
        goto <D.21795>;
        <D.21794>:
        D.21796 = sgen_ptr_in_nursery (start);
        if (D.21796 == 0) goto <D.21797>; else goto <D.21798>;
        <D.21797>:
        D.21799 = *_objptr;
        D.21800 = sgen_ptr_in_nursery (D.21799);
        if (D.21800 != 0) goto <D.21801>; else goto <D.21802>;
        <D.21801>:
        D.21805 = sgen_get_remset ();
        D.21806 = D.21805->find_address;
        D.21807 = D.21806 (_objptr);
        if (D.21807 == 0) goto <D.21808>; else goto <D.21809>;
        <D.21808>:
        D.21799 = *_objptr;
        D.21810 = sgen_cement_lookup (D.21799);
        if (D.21810 == 0) goto <D.21811>; else goto <D.21812>;
        <D.21811>:
        if (allow_missing_pinned == 0) goto <D.21803>; else goto <D.21813>;
        <D.21813>:
        D.21799 = *_objptr;
        D.21814 = MEM[(mword *)D.21799];
        D.21815 = D.21814 & 2;
        if (D.21815 == 0) goto <D.21803>; else goto <D.21804>;
        <D.21803>:
        missing_remset_spew (start, _objptr);
        <D.21804>:
        <D.21812>:
        <D.21809>:
        <D.21802>:
        <D.21798>:
        <D.21795>:
        <D.21791>:
        _objptr = _objptr + 4;
      }
      goto <D.20353>;
      <D.20352>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.124 = (unsigned int) _index;
        D.21817 = _index.124 * 4;
        _objptr = _objptr + D.21817;
        D.21818 = _index + 1;
        _bmap = _bmap >> D.21818;
        D.21789 = MEM[(char * *)_objptr];
        if (D.21789 != 0B) goto <D.21819>; else goto <D.21820>;
        <D.21819>:
        D.21789 = MEM[(char * *)_objptr];
        D.21821 = is_valid_object_pointer (D.21789);
        if (D.21821 == 0) goto <D.21822>; else goto <D.21823>;
        <D.21822>:
        bad_pointer_spew (start, _objptr);
        goto <D.21824>;
        <D.21823>:
        D.21825 = sgen_ptr_in_nursery (start);
        if (D.21825 == 0) goto <D.21826>; else goto <D.21827>;
        <D.21826>:
        D.21799 = *_objptr;
        D.21828 = sgen_ptr_in_nursery (D.21799);
        if (D.21828 != 0) goto <D.21829>; else goto <D.21830>;
        <D.21829>:
        D.21833 = sgen_get_remset ();
        D.21834 = D.21833->find_address;
        D.21835 = D.21834 (_objptr);
        if (D.21835 == 0) goto <D.21836>; else goto <D.21837>;
        <D.21836>:
        D.21799 = *_objptr;
        D.21838 = sgen_cement_lookup (D.21799);
        if (D.21838 == 0) goto <D.21839>; else goto <D.21840>;
        <D.21839>:
        if (allow_missing_pinned == 0) goto <D.21831>; else goto <D.21841>;
        <D.21841>:
        D.21799 = *_objptr;
        D.21814 = MEM[(mword *)D.21799];
        D.21815 = D.21814 & 2;
        if (D.21815 == 0) goto <D.21831>; else goto <D.21832>;
        <D.21831>:
        missing_remset_spew (start, _objptr);
        <D.21832>:
        <D.21840>:
        <D.21837>:
        <D.21830>:
        <D.21827>:
        <D.21824>:
        <D.21820>:
        _objptr = _objptr + 4;
      }
      <D.20353>:
      if (_bmap != 0) goto <D.20352>; else goto <D.20354>;
      <D.20354>:
    }
    goto <D.20346>;
    <D.20355>:
    D.21842 = desc & 4294950912;
    if (D.21842 != 0) goto <D.21843>; else goto <D.21844>;
    <D.21843>:
    {
      int el_size;
      int etype;

      D.21845 = desc >> 3;
      D.21846 = (int) D.21845;
      el_size = D.21846 & 1023;
      desc.125 = (int) desc;
      etype = desc.125 & 49152;
      if (etype == 16384) goto <D.21848>; else goto <D.21849>;
      <D.21848>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.21850 = MEM[(struct MonoArray *)start].max_length;
        el_size.126 = (unsigned int) el_size;
        D.21852 = D.21850 * el_size.126;
        end_refs = p + D.21852;
        goto <D.20361>;
        <D.20360>:
        D.21853 = MEM[(char * *)p];
        if (D.21853 != 0B) goto <D.21854>; else goto <D.21855>;
        <D.21854>:
        D.21853 = MEM[(char * *)p];
        D.21856 = is_valid_object_pointer (D.21853);
        if (D.21856 == 0) goto <D.21857>; else goto <D.21858>;
        <D.21857>:
        bad_pointer_spew (start, p);
        goto <D.21859>;
        <D.21858>:
        D.21860 = sgen_ptr_in_nursery (start);
        if (D.21860 == 0) goto <D.21861>; else goto <D.21862>;
        <D.21861>:
        D.21863 = *p;
        D.21864 = sgen_ptr_in_nursery (D.21863);
        if (D.21864 != 0) goto <D.21865>; else goto <D.21866>;
        <D.21865>:
        D.21869 = sgen_get_remset ();
        D.21870 = D.21869->find_address;
        D.21871 = D.21870 (p);
        if (D.21871 == 0) goto <D.21872>; else goto <D.21873>;
        <D.21872>:
        D.21863 = *p;
        D.21874 = sgen_cement_lookup (D.21863);
        if (D.21874 == 0) goto <D.21875>; else goto <D.21876>;
        <D.21875>:
        if (allow_missing_pinned == 0) goto <D.21867>; else goto <D.21877>;
        <D.21877>:
        D.21863 = *p;
        D.21878 = MEM[(mword *)D.21863];
        D.21879 = D.21878 & 2;
        if (D.21879 == 0) goto <D.21867>; else goto <D.21868>;
        <D.21867>:
        missing_remset_spew (start, p);
        <D.21868>:
        <D.21876>:
        <D.21873>:
        <D.21866>:
        <D.21862>:
        <D.21859>:
        <D.21855>:
        p = p + 4;
        <D.20361>:
        if (p < end_refs) goto <D.20360>; else goto <D.20362>;
        <D.20362>:
      }
      goto <D.21880>;
      <D.21849>:
      if (etype == 32768) goto <D.21881>; else goto <D.21882>;
      <D.21881>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.21731 = desc >> 16;
        D.21883 = (int) D.21731;
        offset = D.21883 & 255;
        D.21734 = desc >> 24;
        num_refs = (int) D.21734;
        e_start = start + 16;
        D.21850 = MEM[(struct MonoArray *)start].max_length;
        el_size.126 = (unsigned int) el_size;
        D.21852 = D.21850 * el_size.126;
        e_end = e_start + D.21852;
        goto <D.20373>;
        <D.20372>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.127 = (unsigned int) offset;
          D.21885 = offset.127 * 4;
          p = p + D.21885;
          i = 0;
          goto <D.20370>;
          <D.20369>:
          D.21886 = MEM[(char * *)p];
          i.128 = (sizetype) i;
          D.21888 = D.21886 + i.128;
          if (D.21888 != 0B) goto <D.21889>; else goto <D.21890>;
          <D.21889>:
          D.21886 = MEM[(char * *)p];
          i.128 = (sizetype) i;
          D.21888 = D.21886 + i.128;
          D.21891 = is_valid_object_pointer (D.21888);
          if (D.21891 == 0) goto <D.21892>; else goto <D.21893>;
          <D.21892>:
          i.129 = (unsigned int) i;
          D.21895 = i.129 * 4;
          D.21896 = p + D.21895;
          bad_pointer_spew (start, D.21896);
          goto <D.21897>;
          <D.21893>:
          D.21898 = sgen_ptr_in_nursery (start);
          if (D.21898 == 0) goto <D.21899>; else goto <D.21900>;
          <D.21899>:
          D.21901 = *p;
          i.128 = (sizetype) i;
          D.21902 = D.21901 + i.128;
          D.21903 = sgen_ptr_in_nursery (D.21902);
          if (D.21903 != 0) goto <D.21904>; else goto <D.21905>;
          <D.21904>:
          D.21908 = sgen_get_remset ();
          D.21909 = D.21908->find_address;
          i.129 = (unsigned int) i;
          D.21895 = i.129 * 4;
          D.21910 = p + D.21895;
          D.21911 = D.21909 (D.21910);
          if (D.21911 == 0) goto <D.21912>; else goto <D.21913>;
          <D.21912>:
          i.129 = (unsigned int) i;
          D.21895 = i.129 * 4;
          D.21914 = p + D.21895;
          D.21915 = *D.21914;
          D.21916 = sgen_cement_lookup (D.21915);
          if (D.21916 == 0) goto <D.21917>; else goto <D.21918>;
          <D.21917>:
          if (allow_missing_pinned == 0) goto <D.21906>; else goto <D.21919>;
          <D.21919>:
          i.129 = (unsigned int) i;
          D.21895 = i.129 * 4;
          D.21914 = p + D.21895;
          D.21915 = *D.21914;
          D.21920 = MEM[(mword *)D.21915];
          D.21921 = D.21920 & 2;
          if (D.21921 == 0) goto <D.21906>; else goto <D.21907>;
          <D.21906>:
          i.129 = (unsigned int) i;
          D.21895 = i.129 * 4;
          D.21896 = p + D.21895;
          missing_remset_spew (start, D.21896);
          <D.21907>:
          <D.21918>:
          <D.21913>:
          <D.21905>:
          <D.21900>:
          <D.21897>:
          <D.21890>:
          i = i + 1;
          <D.20370>:
          if (i < num_refs) goto <D.20369>; else goto <D.20371>;
          <D.20371>:
          el_size.130 = (sizetype) el_size;
          e_start = e_start + el_size.130;
        }
        <D.20373>:
        if (e_start < e_end) goto <D.20372>; else goto <D.20374>;
        <D.20374>:
      }
      goto <D.21923>;
      <D.21882>:
      if (etype == 49152) goto <D.21924>; else goto <D.21925>;
      <D.21924>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.21850 = MEM[(struct MonoArray *)start].max_length;
        el_size.126 = (unsigned int) el_size;
        D.21852 = D.21850 * el_size.126;
        e_end = e_start + D.21852;
        goto <D.20383>;
        <D.20382>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.20380>;
          <D.20379>:
          D.21926 = _bmap & 1;
          if (D.21926 != 0) goto <D.21927>; else goto <D.21928>;
          <D.21927>:
          D.21929 = MEM[(char * *)p];
          if (D.21929 != 0B) goto <D.21930>; else goto <D.21931>;
          <D.21930>:
          D.21929 = MEM[(char * *)p];
          D.21932 = is_valid_object_pointer (D.21929);
          if (D.21932 == 0) goto <D.21933>; else goto <D.21934>;
          <D.21933>:
          bad_pointer_spew (start, p);
          goto <D.21935>;
          <D.21934>:
          D.21936 = sgen_ptr_in_nursery (start);
          if (D.21936 == 0) goto <D.21937>; else goto <D.21938>;
          <D.21937>:
          D.21939 = *p;
          D.21940 = sgen_ptr_in_nursery (D.21939);
          if (D.21940 != 0) goto <D.21941>; else goto <D.21942>;
          <D.21941>:
          D.21945 = sgen_get_remset ();
          D.21946 = D.21945->find_address;
          D.21947 = D.21946 (p);
          if (D.21947 == 0) goto <D.21948>; else goto <D.21949>;
          <D.21948>:
          D.21939 = *p;
          D.21950 = sgen_cement_lookup (D.21939);
          if (D.21950 == 0) goto <D.21951>; else goto <D.21952>;
          <D.21951>:
          if (allow_missing_pinned == 0) goto <D.21943>; else goto <D.21953>;
          <D.21953>:
          D.21939 = *p;
          D.21954 = MEM[(mword *)D.21939];
          D.21955 = D.21954 & 2;
          if (D.21955 == 0) goto <D.21943>; else goto <D.21944>;
          <D.21943>:
          missing_remset_spew (start, p);
          <D.21944>:
          <D.21952>:
          <D.21949>:
          <D.21942>:
          <D.21938>:
          <D.21935>:
          <D.21931>:
          <D.21928>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.20380>:
          if (_bmap != 0) goto <D.20379>; else goto <D.20381>;
          <D.20381>:
          el_size.130 = (sizetype) el_size;
          e_start = e_start + el_size.130;
        }
        <D.20383>:
        if (e_start < e_end) goto <D.20382>; else goto <D.20384>;
        <D.20384>:
      }
      <D.21925>:
      <D.21923>:
      <D.21880>:
    }
    <D.21844>:
    goto <D.20346>;
    <D.20385>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.20389>;
      <D.20388>:
      D.21956 = _bmap & 1;
      if (D.21956 != 0) goto <D.21957>; else goto <D.21958>;
      <D.21957>:
      D.21959 = MEM[(char * *)_objptr];
      if (D.21959 != 0B) goto <D.21960>; else goto <D.21961>;
      <D.21960>:
      D.21959 = MEM[(char * *)_objptr];
      D.21962 = is_valid_object_pointer (D.21959);
      if (D.21962 == 0) goto <D.21963>; else goto <D.21964>;
      <D.21963>:
      bad_pointer_spew (start, _objptr);
      goto <D.21965>;
      <D.21964>:
      D.21966 = sgen_ptr_in_nursery (start);
      if (D.21966 == 0) goto <D.21967>; else goto <D.21968>;
      <D.21967>:
      D.21969 = *_objptr;
      D.21970 = sgen_ptr_in_nursery (D.21969);
      if (D.21970 != 0) goto <D.21971>; else goto <D.21972>;
      <D.21971>:
      D.21975 = sgen_get_remset ();
      D.21976 = D.21975->find_address;
      D.21977 = D.21976 (_objptr);
      if (D.21977 == 0) goto <D.21978>; else goto <D.21979>;
      <D.21978>:
      D.21969 = *_objptr;
      D.21980 = sgen_cement_lookup (D.21969);
      if (D.21980 == 0) goto <D.21981>; else goto <D.21982>;
      <D.21981>:
      if (allow_missing_pinned == 0) goto <D.21973>; else goto <D.21983>;
      <D.21983>:
      D.21969 = *_objptr;
      D.21984 = MEM[(mword *)D.21969];
      D.21985 = D.21984 & 2;
      if (D.21985 == 0) goto <D.21973>; else goto <D.21974>;
      <D.21973>:
      missing_remset_spew (start, _objptr);
      <D.21974>:
      <D.21982>:
      <D.21979>:
      <D.21972>:
      <D.21968>:
      <D.21965>:
      <D.21961>:
      <D.21958>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20389>:
      if (_bmap != 0) goto <D.20388>; else goto <D.20390>;
      <D.20390>:
    }
    goto <D.20346>;
    <D.20391>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.21986 = *bitmap_data;
      D.21987 = D.21986 + 4294967295;
      bwords = (int) D.21987;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.21988>; else goto <D.21989>;
      <D.21988>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.21990 = myobj->vtable;
        D.21991 = D.21990->klass;
        D.21992 = D.21991->name_space;
        D.21990 = myobj->vtable;
        D.21991 = D.21990->klass;
        D.21993 = D.21991->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.21992, D.21993);
      }
      <D.21989>:
      goto <D.20402>;
      <D.20401>:
      {
        gsize _bmap;

        bitmap_data.131 = bitmap_data;
        bitmap_data = bitmap_data.131 + 4;
        _bmap = *bitmap_data.131;
        _objptr = start_run;
        goto <D.20399>;
        <D.20398>:
        D.21995 = _bmap & 1;
        if (D.21995 != 0) goto <D.21996>; else goto <D.21997>;
        <D.21996>:
        D.21998 = MEM[(char * *)_objptr];
        if (D.21998 != 0B) goto <D.21999>; else goto <D.22000>;
        <D.21999>:
        D.21998 = MEM[(char * *)_objptr];
        D.22001 = is_valid_object_pointer (D.21998);
        if (D.22001 == 0) goto <D.22002>; else goto <D.22003>;
        <D.22002>:
        bad_pointer_spew (start, _objptr);
        goto <D.22004>;
        <D.22003>:
        D.22005 = sgen_ptr_in_nursery (start);
        if (D.22005 == 0) goto <D.22006>; else goto <D.22007>;
        <D.22006>:
        D.22008 = *_objptr;
        D.22009 = sgen_ptr_in_nursery (D.22008);
        if (D.22009 != 0) goto <D.22010>; else goto <D.22011>;
        <D.22010>:
        D.22014 = sgen_get_remset ();
        D.22015 = D.22014->find_address;
        D.22016 = D.22015 (_objptr);
        if (D.22016 == 0) goto <D.22017>; else goto <D.22018>;
        <D.22017>:
        D.22008 = *_objptr;
        D.22019 = sgen_cement_lookup (D.22008);
        if (D.22019 == 0) goto <D.22020>; else goto <D.22021>;
        <D.22020>:
        if (allow_missing_pinned == 0) goto <D.22012>; else goto <D.22022>;
        <D.22022>:
        D.22008 = *_objptr;
        D.22023 = MEM[(mword *)D.22008];
        D.22024 = D.22023 & 2;
        if (D.22024 == 0) goto <D.22012>; else goto <D.22013>;
        <D.22012>:
        missing_remset_spew (start, _objptr);
        <D.22013>:
        <D.22021>:
        <D.22018>:
        <D.22011>:
        <D.22007>:
        <D.22004>:
        <D.22000>:
        <D.21997>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.20399>:
        if (_bmap != 0) goto <D.20398>; else goto <D.20400>;
        <D.20400>:
        start_run = start_run + 128;
      }
      <D.20402>:
      bwords.132 = bwords;
      bwords = bwords.132 + -1;
      if (bwords.132 > 0) goto <D.20401>; else goto <D.20403>;
      <D.20403>:
    }
    goto <D.20346>;
    <D.20404>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.22026 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.22026);
      mbitmap_data.133 = mbitmap_data;
      mbitmap_data = mbitmap_data.133 + 4;
      D.22028 = *mbitmap_data.133;
      D.22029 = D.22028 + 4294967295;
      mbwords = (int) D.22029;
      D.22030 = vt->klass;
      el_size = mono_array_element_size (D.22030);
      e_start = start + 16;
      D.21850 = MEM[(struct MonoArray *)start].max_length;
      el_size.134 = (unsigned int) el_size;
      D.22032 = D.21850 * el_size.134;
      e_end = e_start + D.22032;
      if (0 != 0) goto <D.22033>; else goto <D.22034>;
      <D.22033>:
      D.22026 = vt->desc;
      D.22030 = vt->klass;
      D.22035 = D.22030->name_space;
      D.22030 = vt->klass;
      D.22036 = D.22030->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.22026, D.22035, D.22036);
      <D.22034>:
      goto <D.20422>;
      <D.20421>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.135 = bitmap_data;
          bitmap_data = bitmap_data.135 + 4;
          _bmap = *bitmap_data.135;
          start_run = _objptr;
          goto <D.20416>;
          <D.20415>:
          D.22038 = _bmap & 1;
          if (D.22038 != 0) goto <D.22039>; else goto <D.22040>;
          <D.22039>:
          D.22041 = MEM[(char * *)_objptr];
          if (D.22041 != 0B) goto <D.22042>; else goto <D.22043>;
          <D.22042>:
          D.22041 = MEM[(char * *)_objptr];
          D.22044 = is_valid_object_pointer (D.22041);
          if (D.22044 == 0) goto <D.22045>; else goto <D.22046>;
          <D.22045>:
          bad_pointer_spew (start, _objptr);
          goto <D.22047>;
          <D.22046>:
          D.22048 = sgen_ptr_in_nursery (start);
          if (D.22048 == 0) goto <D.22049>; else goto <D.22050>;
          <D.22049>:
          D.22051 = *_objptr;
          D.22052 = sgen_ptr_in_nursery (D.22051);
          if (D.22052 != 0) goto <D.22053>; else goto <D.22054>;
          <D.22053>:
          D.22057 = sgen_get_remset ();
          D.22058 = D.22057->find_address;
          D.22059 = D.22058 (_objptr);
          if (D.22059 == 0) goto <D.22060>; else goto <D.22061>;
          <D.22060>:
          D.22051 = *_objptr;
          D.22062 = sgen_cement_lookup (D.22051);
          if (D.22062 == 0) goto <D.22063>; else goto <D.22064>;
          <D.22063>:
          if (allow_missing_pinned == 0) goto <D.22055>; else goto <D.22065>;
          <D.22065>:
          D.22051 = *_objptr;
          D.22066 = MEM[(mword *)D.22051];
          D.22067 = D.22066 & 2;
          if (D.22067 == 0) goto <D.22055>; else goto <D.22056>;
          <D.22055>:
          missing_remset_spew (start, _objptr);
          <D.22056>:
          <D.22064>:
          <D.22061>:
          <D.22054>:
          <D.22050>:
          <D.22047>:
          <D.22043>:
          <D.22040>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.20416>:
          if (_bmap != 0) goto <D.20415>; else goto <D.20417>;
          <D.20417>:
          _objptr = start_run + 128;
        }
        <D.20419>:
        bwords.136 = bwords;
        bwords = bwords.136 + 4294967295;
        if (bwords.136 != 0) goto <D.20418>; else goto <D.20420>;
        <D.20420>:
        el_size.137 = (sizetype) el_size;
        e_start = e_start + el_size.137;
      }
      <D.20422>:
      if (e_start < e_end) goto <D.20421>; else goto <D.20423>;
      <D.20423>:
    }
    goto <D.20346>;
    <D.20424>:
    goto <D.20346>;
    <D.20425>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.20346>:
  }
}


is_valid_object_pointer (char * object)
{
  int D.22071;
  gboolean D.22074;
  int D.22075;
  gboolean (*<T3655>) (char *) D.22078;
  int D.22079;

  D.22071 = sgen_ptr_in_nursery (object);
  if (D.22071 != 0) goto <D.22072>; else goto <D.22073>;
  <D.22072>:
  D.22074 = find_object_in_nursery_dump (object);
  return D.22074;
  <D.22073>:
  D.22075 = sgen_los_is_valid_object (object);
  if (D.22075 != 0) goto <D.22076>; else goto <D.22077>;
  <D.22076>:
  D.22074 = 1;
  return D.22074;
  <D.22077>:
  D.22078 = major_collector.is_valid_object;
  D.22079 = D.22078 (object);
  if (D.22079 != 0) goto <D.22080>; else goto <D.22081>;
  <D.22080>:
  D.22074 = 1;
  return D.22074;
  <D.22081>:
  D.22074 = 0;
  return D.22074;
}


find_object_in_nursery_dump (char * object)
{
  int D.22083;
  int D.22084;
  char * * valid_nursery_objects.138;
  unsigned int middle.139;
  unsigned int D.22087;
  char * * D.22088;
  char * D.22089;
  gboolean D.22092;
  _Bool D.22096;
  long int D.22097;
  long int D.22098;
  int first;
  int last;

  first = 0;
  last = valid_nursery_object_count;
  goto <D.20306>;
  <D.20305>:
  {
    int middle;

    D.22083 = last - first;
    D.22084 = D.22083 >> 1;
    middle = D.22084 + first;
    valid_nursery_objects.138 = valid_nursery_objects;
    middle.139 = (unsigned int) middle;
    D.22087 = middle.139 * 4;
    D.22088 = valid_nursery_objects.138 + D.22087;
    D.22089 = *D.22088;
    if (D.22089 == object) goto <D.22090>; else goto <D.22091>;
    <D.22090>:
    D.22092 = 1;
    return D.22092;
    <D.22091>:
    valid_nursery_objects.138 = valid_nursery_objects;
    middle.139 = (unsigned int) middle;
    D.22087 = middle.139 * 4;
    D.22088 = valid_nursery_objects.138 + D.22087;
    D.22089 = *D.22088;
    if (D.22089 > object) goto <D.22093>; else goto <D.22094>;
    <D.22093>:
    last = middle;
    goto <D.22095>;
    <D.22094>:
    first = middle + 1;
    <D.22095>:
  }
  <D.20306>:
  if (first < last) goto <D.20305>; else goto <D.20307>;
  <D.20307>:
  D.22096 = first != last;
  D.22097 = (long int) D.22096;
  D.22098 = __builtin_expect (D.22097, 0);
  if (D.22098 != 0) goto <D.22099>; else goto <D.22100>;
  <D.22099>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 337, "first == last");
  <D.22100>:
  D.22092 = 0;
  return D.22092;
}


bad_pointer_spew (char * obj, char * * slot)
{
  unsigned int D.22102;
  unsigned int D.22103;
  int gc_debug_level.140;
  _Bool D.22105;
  long int D.22106;
  long int D.22107;
  struct FILE * gc_debug_file.141;
  int slot.142;
  int obj.143;
  int D.22113;
  struct MonoClass * D.22114;
  const char * D.22115;
  const char * D.22116;
  char * ptr;
  struct MonoVTable * vtable;

  ptr = *slot;
  D.22102 = MEM[(mword *)obj];
  D.22103 = D.22102 & 4294967292;
  vtable = (struct MonoVTable *) D.22103;
  gc_debug_level.140 = gc_debug_level;
  D.22105 = gc_debug_level.140 >= 0;
  D.22106 = (long int) D.22105;
  D.22107 = __builtin_expect (D.22106, 0);
  if (D.22107 != 0) goto <D.22108>; else goto <D.22109>;
  <D.22108>:
  gc_debug_file.141 = gc_debug_file;
  slot.142 = (int) slot;
  obj.143 = (int) obj;
  D.22113 = slot.142 - obj.143;
  D.22114 = vtable->klass;
  D.22115 = D.22114->name_space;
  D.22114 = vtable->klass;
  D.22116 = D.22114->name;
  fprintf (gc_debug_file.141, "Invalid object pointer %p at offset %td in object %p (%s.%s):\n", ptr, D.22113, obj, D.22115, D.22116);
  gc_debug_file.141 = gc_debug_file;
  fflush (gc_debug_file.141);
  <D.22109>:
  describe_pointer (ptr, 0);
  broken_heap = 1;
}


missing_remset_spew (char * obj, char * * slot)
{
  unsigned int D.22117;
  unsigned int D.22118;
  int gc_debug_level.144;
  _Bool D.22120;
  long int D.22121;
  long int D.22122;
  struct FILE * gc_debug_file.145;
  int slot.146;
  int obj.147;
  int D.22128;
  struct MonoClass * D.22129;
  const char * D.22130;
  const char * D.22131;
  char * ptr;
  struct MonoVTable * vtable;

  ptr = *slot;
  D.22117 = MEM[(mword *)obj];
  D.22118 = D.22117 & 4294967292;
  vtable = (struct MonoVTable *) D.22118;
  gc_debug_level.144 = gc_debug_level;
  D.22120 = gc_debug_level.144 >= 0;
  D.22121 = (long int) D.22120;
  D.22122 = __builtin_expect (D.22121, 0);
  if (D.22122 != 0) goto <D.22123>; else goto <D.22124>;
  <D.22123>:
  gc_debug_file.145 = gc_debug_file;
  slot.146 = (int) slot;
  obj.147 = (int) obj;
  D.22128 = slot.146 - obj.147;
  D.22129 = vtable->klass;
  D.22130 = D.22129->name_space;
  D.22129 = vtable->klass;
  D.22131 = D.22129->name;
  fprintf (gc_debug_file.145, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", ptr, D.22128, obj, D.22130, D.22131);
  gc_debug_file.145 = gc_debug_file;
  fflush (gc_debug_file.145);
  <D.22124>:
  broken_heap = 1;
}


sgen_check_objref (char * obj)
{
  int D.22132;
  _Bool D.22133;
  long int D.22134;
  long int D.22135;

  D.22132 = ptr_in_heap (obj);
  D.22133 = D.22132 == 0;
  D.22134 = (long int) D.22133;
  D.22135 = __builtin_expect (D.22134, 0);
  if (D.22135 != 0) goto <D.22136>; else goto <D.22137>;
  <D.22136>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 469, "ptr_in_heap (obj)");
  <D.22137>:
}


ptr_in_heap (char * object)
{
  int D.22138;
  gboolean D.22141;
  int D.22142;
  gboolean (*<T3655>) (char *) D.22145;
  int D.22146;

  D.22138 = sgen_ptr_in_nursery (object);
  if (D.22138 != 0) goto <D.22139>; else goto <D.22140>;
  <D.22139>:
  D.22141 = 1;
  return D.22141;
  <D.22140>:
  D.22142 = sgen_los_is_valid_object (object);
  if (D.22142 != 0) goto <D.22143>; else goto <D.22144>;
  <D.22143>:
  D.22141 = 1;
  return D.22141;
  <D.22144>:
  D.22145 = major_collector.is_valid_object;
  D.22146 = D.22145 (object);
  if (D.22146 != 0) goto <D.22147>; else goto <D.22148>;
  <D.22147>:
  D.22141 = 1;
  return D.22141;
  <D.22148>:
  D.22141 = 0;
  return D.22141;
}


sgen_check_major_heap_marked ()
{
  void (*<T36af>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.22150;

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


check_marked_callback (char * start, size_t size, void * dummy)
{
  int D.22153;
  gboolean (*<T3655>) (char *) D.22157;
  int D.22158;
  unsigned int D.22161;
  unsigned int D.22162;
  unsigned int D.22163;
  unsigned int D.22164;
  unsigned int D.22167;
  unsigned int D.22168;
  unsigned int D.22169;
  unsigned int D.22170;
  unsigned int D.22171;
  int D.22174;
  _Bool D.22175;
  long int D.22176;
  long int D.22177;
  int D.22180;
  unsigned int D.22183;
  unsigned int D.22184;
  _Bool D.22185;
  long int D.22186;
  long int D.22187;
  int D.22191;
  int D.22194;
  _Bool D.22195;
  long int D.22196;
  long int D.22197;
  gboolean (*<T3655>) (char *) D.22201;
  int D.22202;
  int D.22205;
  _Bool D.22206;
  long int D.22207;
  long int D.22208;
  int D.22214;
  _Bool D.22215;
  long int D.22216;
  long int D.22217;
  int D.22220;
  unsigned int D.22223;
  unsigned int D.22224;
  _Bool D.22225;
  long int D.22226;
  long int D.22227;
  int D.22231;
  int D.22234;
  _Bool D.22235;
  long int D.22236;
  long int D.22237;
  int D.22241;
  int D.22244;
  _Bool D.22245;
  long int D.22246;
  long int D.22247;
  unsigned int _index.148;
  unsigned int D.22252;
  int D.22253;
  int D.22256;
  _Bool D.22257;
  long int D.22258;
  long int D.22259;
  int D.22262;
  unsigned int D.22265;
  unsigned int D.22266;
  _Bool D.22267;
  long int D.22268;
  long int D.22269;
  int D.22273;
  int D.22276;
  _Bool D.22277;
  long int D.22278;
  long int D.22279;
  int D.22283;
  int D.22286;
  _Bool D.22287;
  long int D.22288;
  long int D.22289;
  unsigned int _index.149;
  unsigned int D.22294;
  int D.22295;
  int D.22298;
  _Bool D.22299;
  long int D.22300;
  long int D.22301;
  int D.22304;
  unsigned int D.22307;
  unsigned int D.22308;
  _Bool D.22309;
  long int D.22310;
  long int D.22311;
  int D.22315;
  int D.22318;
  _Bool D.22319;
  long int D.22320;
  long int D.22321;
  int D.22325;
  int D.22328;
  _Bool D.22329;
  long int D.22330;
  long int D.22331;
  unsigned int D.22335;
  unsigned int D.22338;
  int D.22339;
  int desc.150;
  unsigned int D.22343;
  unsigned int el_size.151;
  unsigned int D.22345;
  int D.22348;
  _Bool D.22349;
  long int D.22350;
  long int D.22351;
  int D.22354;
  unsigned int D.22357;
  unsigned int D.22358;
  _Bool D.22359;
  long int D.22360;
  long int D.22361;
  int D.22365;
  int D.22368;
  _Bool D.22369;
  long int D.22370;
  long int D.22371;
  int D.22375;
  int D.22378;
  _Bool D.22379;
  long int D.22380;
  long int D.22381;
  int D.22388;
  unsigned int offset.152;
  unsigned int D.22390;
  char * D.22391;
  sizetype i.153;
  int D.22395;
  _Bool D.22396;
  long int D.22397;
  long int D.22398;
  int D.22401;
  unsigned int D.22404;
  unsigned int D.22405;
  _Bool D.22406;
  long int D.22407;
  long int D.22408;
  int D.22412;
  int D.22415;
  _Bool D.22416;
  long int D.22417;
  long int D.22418;
  int D.22422;
  int D.22425;
  _Bool D.22426;
  long int D.22427;
  long int D.22428;
  sizetype el_size.154;
  unsigned int D.22436;
  int D.22441;
  _Bool D.22442;
  long int D.22443;
  long int D.22444;
  int D.22447;
  unsigned int D.22450;
  unsigned int D.22451;
  _Bool D.22452;
  long int D.22453;
  long int D.22454;
  int D.22458;
  int D.22461;
  _Bool D.22462;
  long int D.22463;
  long int D.22464;
  int D.22468;
  int D.22471;
  _Bool D.22472;
  long int D.22473;
  long int D.22474;
  unsigned int D.22478;
  int D.22483;
  _Bool D.22484;
  long int D.22485;
  long int D.22486;
  int D.22489;
  unsigned int D.22492;
  unsigned int D.22493;
  _Bool D.22494;
  long int D.22495;
  long int D.22496;
  int D.22500;
  int D.22503;
  _Bool D.22504;
  long int D.22505;
  long int D.22506;
  int D.22510;
  int D.22513;
  _Bool D.22514;
  long int D.22515;
  long int D.22516;
  unsigned int D.22520;
  unsigned int D.22521;
  struct MonoVTable * D.22524;
  struct MonoClass * D.22525;
  const char * D.22526;
  const char * D.22527;
  gsize * bitmap_data.155;
  unsigned int D.22529;
  int D.22534;
  _Bool D.22535;
  long int D.22536;
  long int D.22537;
  int D.22540;
  unsigned int D.22543;
  unsigned int D.22544;
  _Bool D.22545;
  long int D.22546;
  long int D.22547;
  int D.22551;
  int D.22554;
  _Bool D.22555;
  long int D.22556;
  long int D.22557;
  int D.22561;
  int D.22564;
  _Bool D.22565;
  long int D.22566;
  long int D.22567;
  int bwords.156;
  unsigned int D.22572;
  gsize * mbitmap_data.157;
  unsigned int D.22574;
  unsigned int D.22575;
  struct MonoClass * D.22576;
  unsigned int el_size.158;
  unsigned int D.22578;
  const char * D.22581;
  const char * D.22582;
  gsize * bitmap_data.159;
  unsigned int D.22584;
  int D.22589;
  _Bool D.22590;
  long int D.22591;
  long int D.22592;
  int D.22595;
  unsigned int D.22598;
  unsigned int D.22599;
  _Bool D.22600;
  long int D.22601;
  long int D.22602;
  int D.22606;
  int D.22609;
  _Bool D.22610;
  long int D.22611;
  long int D.22612;
  int D.22616;
  int D.22619;
  _Bool D.22620;
  long int D.22621;
  long int D.22622;
  unsigned int bwords.160;
  sizetype el_size.161;
  gboolean is_los;

  is_los = (gboolean) dummy;
  if (is_los != 0) goto <D.22151>; else goto <D.22152>;
  <D.22151>:
  D.22153 = sgen_los_object_is_pinned (start);
  if (D.22153 == 0) goto <D.22154>; else goto <D.22155>;
  <D.22154>:
  return;
  <D.22155>:
  goto <D.22156>;
  <D.22152>:
  D.22157 = major_collector.is_object_live;
  D.22158 = D.22157 (start);
  if (D.22158 == 0) goto <D.22159>; else goto <D.22160>;
  <D.22159>:
  return;
  <D.22160>:
  <D.22156>:
  {
    struct GCVTable * vt;
    mword desc;

    D.22161 = MEM[(mword *)start];
    D.22162 = D.22161 & 4294967292;
    vt = (struct GCVTable *) D.22162;
    desc = vt->desc;
    D.22163 = desc & 7;
    switch (D.22163) <default: <D.20580>, case 1: <D.20485>, case 2: <D.20494>, case 3: <D.20544>, case 4: <D.20504>, case 5: <D.20537>, case 6: <D.20558>, case 7: <D.20579>>
    <D.20485>:
    D.22164 = desc & 4294901760;
    if (D.22164 != 0) goto <D.22165>; else goto <D.22166>;
    <D.22165>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.22167 = desc >> 16;
      D.22168 = D.22167 & 255;
      D.22169 = D.22168 * 4;
      _objptr = _objptr + D.22169;
      D.22170 = desc >> 24;
      D.22171 = D.22170 * 4;
      _objptr_end = _objptr + D.22171;
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.22172>; else goto <D.22173>;
        <D.22172>:
        D.22174 = is_valid_object_pointer (__target);
        D.22175 = D.22174 == 0;
        D.22176 = (long int) D.22175;
        D.22177 = __builtin_expect (D.22176, 0);
        if (D.22177 != 0) goto <D.22178>; else goto <D.22179>;
        <D.22178>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "is_valid_object_pointer (__target)");
        <D.22179>:
        D.22180 = sgen_ptr_in_nursery (__target);
        if (D.22180 != 0) goto <D.22181>; else goto <D.22182>;
        <D.22181>:
        D.22183 = MEM[(mword *)__target];
        D.22184 = D.22183 & 2;
        D.22185 = D.22184 == 0;
        D.22186 = (long int) D.22185;
        D.22187 = __builtin_expect (D.22186, 0);
        if (D.22187 != 0) goto <D.22188>; else goto <D.22189>;
        <D.22188>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.22189>:
        goto <D.22190>;
        <D.22182>:
        D.22191 = sgen_los_is_valid_object (__target);
        if (D.22191 != 0) goto <D.22192>; else goto <D.22193>;
        <D.22192>:
        D.22194 = sgen_los_object_is_pinned (__target);
        D.22195 = D.22194 == 0;
        D.22196 = (long int) D.22195;
        D.22197 = __builtin_expect (D.22196, 0);
        if (D.22197 != 0) goto <D.22198>; else goto <D.22199>;
        <D.22198>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_los_object_is_pinned (__target)");
        <D.22199>:
        goto <D.22200>;
        <D.22193>:
        D.22201 = major_collector.is_valid_object;
        D.22202 = D.22201 (__target);
        if (D.22202 != 0) goto <D.22203>; else goto <D.22204>;
        <D.22203>:
        D.22157 = major_collector.is_object_live;
        D.22205 = D.22157 (__target);
        D.22206 = D.22205 == 0;
        D.22207 = (long int) D.22206;
        D.22208 = __builtin_expect (D.22207, 0);
        if (D.22208 != 0) goto <D.22209>; else goto <D.22210>;
        <D.22209>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "major_collector.is_object_live (__target)");
        <D.22210>:
        goto <D.22211>;
        <D.22204>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 64);
        <D.22211>:
        <D.22200>:
        <D.22190>:
        <D.22173>:
      }
      _objptr = _objptr + 4;
      goto <D.20491>;
      <D.20490>:
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.22212>; else goto <D.22213>;
        <D.22212>:
        D.22214 = is_valid_object_pointer (__target);
        D.22215 = D.22214 == 0;
        D.22216 = (long int) D.22215;
        D.22217 = __builtin_expect (D.22216, 0);
        if (D.22217 != 0) goto <D.22218>; else goto <D.22219>;
        <D.22218>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "is_valid_object_pointer (__target)");
        <D.22219>:
        D.22220 = sgen_ptr_in_nursery (__target);
        if (D.22220 != 0) goto <D.22221>; else goto <D.22222>;
        <D.22221>:
        D.22223 = MEM[(mword *)__target];
        D.22224 = D.22223 & 2;
        D.22225 = D.22224 == 0;
        D.22226 = (long int) D.22225;
        D.22227 = __builtin_expect (D.22226, 0);
        if (D.22227 != 0) goto <D.22228>; else goto <D.22229>;
        <D.22228>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.22229>:
        goto <D.22230>;
        <D.22222>:
        D.22231 = sgen_los_is_valid_object (__target);
        if (D.22231 != 0) goto <D.22232>; else goto <D.22233>;
        <D.22232>:
        D.22234 = sgen_los_object_is_pinned (__target);
        D.22235 = D.22234 == 0;
        D.22236 = (long int) D.22235;
        D.22237 = __builtin_expect (D.22236, 0);
        if (D.22237 != 0) goto <D.22238>; else goto <D.22239>;
        <D.22238>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_los_object_is_pinned (__target)");
        <D.22239>:
        goto <D.22240>;
        <D.22233>:
        D.22201 = major_collector.is_valid_object;
        D.22241 = D.22201 (__target);
        if (D.22241 != 0) goto <D.22242>; else goto <D.22243>;
        <D.22242>:
        D.22157 = major_collector.is_object_live;
        D.22244 = D.22157 (__target);
        D.22245 = D.22244 == 0;
        D.22246 = (long int) D.22245;
        D.22247 = __builtin_expect (D.22246, 0);
        if (D.22247 != 0) goto <D.22248>; else goto <D.22249>;
        <D.22248>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "major_collector.is_object_live (__target)");
        <D.22249>:
        goto <D.22250>;
        <D.22243>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 64);
        <D.22250>:
        <D.22240>:
        <D.22230>:
        <D.22213>:
      }
      _objptr = _objptr + 4;
      <D.20491>:
      if (_objptr < _objptr_end) goto <D.20490>; else goto <D.20492>;
      <D.20492>:
    }
    <D.22166>:
    goto <D.20493>;
    <D.20494>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.148 = (unsigned int) _index;
        D.22252 = _index.148 * 4;
        _objptr = _objptr + D.22252;
        D.22253 = _index + 1;
        _bmap = _bmap >> D.22253;
        {
          char * __target;

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.22254>; else goto <D.22255>;
          <D.22254>:
          D.22256 = is_valid_object_pointer (__target);
          D.22257 = D.22256 == 0;
          D.22258 = (long int) D.22257;
          D.22259 = __builtin_expect (D.22258, 0);
          if (D.22259 != 0) goto <D.22260>; else goto <D.22261>;
          <D.22260>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "is_valid_object_pointer (__target)");
          <D.22261>:
          D.22262 = sgen_ptr_in_nursery (__target);
          if (D.22262 != 0) goto <D.22263>; else goto <D.22264>;
          <D.22263>:
          D.22265 = MEM[(mword *)__target];
          D.22266 = D.22265 & 2;
          D.22267 = D.22266 == 0;
          D.22268 = (long int) D.22267;
          D.22269 = __builtin_expect (D.22268, 0);
          if (D.22269 != 0) goto <D.22270>; else goto <D.22271>;
          <D.22270>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.22271>:
          goto <D.22272>;
          <D.22264>:
          D.22273 = sgen_los_is_valid_object (__target);
          if (D.22273 != 0) goto <D.22274>; else goto <D.22275>;
          <D.22274>:
          D.22276 = sgen_los_object_is_pinned (__target);
          D.22277 = D.22276 == 0;
          D.22278 = (long int) D.22277;
          D.22279 = __builtin_expect (D.22278, 0);
          if (D.22279 != 0) goto <D.22280>; else goto <D.22281>;
          <D.22280>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_los_object_is_pinned (__target)");
          <D.22281>:
          goto <D.22282>;
          <D.22275>:
          D.22201 = major_collector.is_valid_object;
          D.22283 = D.22201 (__target);
          if (D.22283 != 0) goto <D.22284>; else goto <D.22285>;
          <D.22284>:
          D.22157 = major_collector.is_object_live;
          D.22286 = D.22157 (__target);
          D.22287 = D.22286 == 0;
          D.22288 = (long int) D.22287;
          D.22289 = __builtin_expect (D.22288, 0);
          if (D.22289 != 0) goto <D.22290>; else goto <D.22291>;
          <D.22290>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "major_collector.is_object_live (__target)");
          <D.22291>:
          goto <D.22292>;
          <D.22285>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 71);
          <D.22292>:
          <D.22282>:
          <D.22272>:
          <D.22255>:
        }
        _objptr = _objptr + 4;
      }
      goto <D.20502>;
      <D.20501>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.149 = (unsigned int) _index;
        D.22294 = _index.149 * 4;
        _objptr = _objptr + D.22294;
        D.22295 = _index + 1;
        _bmap = _bmap >> D.22295;
        {
          char * __target;

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.22296>; else goto <D.22297>;
          <D.22296>:
          D.22298 = is_valid_object_pointer (__target);
          D.22299 = D.22298 == 0;
          D.22300 = (long int) D.22299;
          D.22301 = __builtin_expect (D.22300, 0);
          if (D.22301 != 0) goto <D.22302>; else goto <D.22303>;
          <D.22302>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "is_valid_object_pointer (__target)");
          <D.22303>:
          D.22304 = sgen_ptr_in_nursery (__target);
          if (D.22304 != 0) goto <D.22305>; else goto <D.22306>;
          <D.22305>:
          D.22307 = MEM[(mword *)__target];
          D.22308 = D.22307 & 2;
          D.22309 = D.22308 == 0;
          D.22310 = (long int) D.22309;
          D.22311 = __builtin_expect (D.22310, 0);
          if (D.22311 != 0) goto <D.22312>; else goto <D.22313>;
          <D.22312>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.22313>:
          goto <D.22314>;
          <D.22306>:
          D.22315 = sgen_los_is_valid_object (__target);
          if (D.22315 != 0) goto <D.22316>; else goto <D.22317>;
          <D.22316>:
          D.22318 = sgen_los_object_is_pinned (__target);
          D.22319 = D.22318 == 0;
          D.22320 = (long int) D.22319;
          D.22321 = __builtin_expect (D.22320, 0);
          if (D.22321 != 0) goto <D.22322>; else goto <D.22323>;
          <D.22322>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_los_object_is_pinned (__target)");
          <D.22323>:
          goto <D.22324>;
          <D.22317>:
          D.22201 = major_collector.is_valid_object;
          D.22325 = D.22201 (__target);
          if (D.22325 != 0) goto <D.22326>; else goto <D.22327>;
          <D.22326>:
          D.22157 = major_collector.is_object_live;
          D.22328 = D.22157 (__target);
          D.22329 = D.22328 == 0;
          D.22330 = (long int) D.22329;
          D.22331 = __builtin_expect (D.22330, 0);
          if (D.22331 != 0) goto <D.22332>; else goto <D.22333>;
          <D.22332>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "major_collector.is_object_live (__target)");
          <D.22333>:
          goto <D.22334>;
          <D.22327>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 71);
          <D.22334>:
          <D.22324>:
          <D.22314>:
          <D.22297>:
        }
        _objptr = _objptr + 4;
      }
      <D.20502>:
      if (_bmap != 0) goto <D.20501>; else goto <D.20503>;
      <D.20503>:
    }
    goto <D.20493>;
    <D.20504>:
    D.22335 = desc & 4294950912;
    if (D.22335 != 0) goto <D.22336>; else goto <D.22337>;
    <D.22336>:
    {
      int el_size;
      int etype;

      D.22338 = desc >> 3;
      D.22339 = (int) D.22338;
      el_size = D.22339 & 1023;
      desc.150 = (int) desc;
      etype = desc.150 & 49152;
      if (etype == 16384) goto <D.22341>; else goto <D.22342>;
      <D.22341>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.22343 = MEM[(struct MonoArray *)start].max_length;
        el_size.151 = (unsigned int) el_size;
        D.22345 = D.22343 * el_size.151;
        end_refs = p + D.22345;
        goto <D.20511>;
        <D.20510>:
        {
          char * __target;

          __target = MEM[(char * *)p];
          if (__target != 0B) goto <D.22346>; else goto <D.22347>;
          <D.22346>:
          D.22348 = is_valid_object_pointer (__target);
          D.22349 = D.22348 == 0;
          D.22350 = (long int) D.22349;
          D.22351 = __builtin_expect (D.22350, 0);
          if (D.22351 != 0) goto <D.22352>; else goto <D.22353>;
          <D.22352>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "is_valid_object_pointer (__target)");
          <D.22353>:
          D.22354 = sgen_ptr_in_nursery (__target);
          if (D.22354 != 0) goto <D.22355>; else goto <D.22356>;
          <D.22355>:
          D.22357 = MEM[(mword *)__target];
          D.22358 = D.22357 & 2;
          D.22359 = D.22358 == 0;
          D.22360 = (long int) D.22359;
          D.22361 = __builtin_expect (D.22360, 0);
          if (D.22361 != 0) goto <D.22362>; else goto <D.22363>;
          <D.22362>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.22363>:
          goto <D.22364>;
          <D.22356>:
          D.22365 = sgen_los_is_valid_object (__target);
          if (D.22365 != 0) goto <D.22366>; else goto <D.22367>;
          <D.22366>:
          D.22368 = sgen_los_object_is_pinned (__target);
          D.22369 = D.22368 == 0;
          D.22370 = (long int) D.22369;
          D.22371 = __builtin_expect (D.22370, 0);
          if (D.22371 != 0) goto <D.22372>; else goto <D.22373>;
          <D.22372>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
          <D.22373>:
          goto <D.22374>;
          <D.22367>:
          D.22201 = major_collector.is_valid_object;
          D.22375 = D.22201 (__target);
          if (D.22375 != 0) goto <D.22376>; else goto <D.22377>;
          <D.22376>:
          D.22157 = major_collector.is_object_live;
          D.22378 = D.22157 (__target);
          D.22379 = D.22378 == 0;
          D.22380 = (long int) D.22379;
          D.22381 = __builtin_expect (D.22380, 0);
          if (D.22381 != 0) goto <D.22382>; else goto <D.22383>;
          <D.22382>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
          <D.22383>:
          goto <D.22384>;
          <D.22377>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
          <D.22384>:
          <D.22374>:
          <D.22364>:
          <D.22347>:
        }
        p = p + 4;
        <D.20511>:
        if (p < end_refs) goto <D.20510>; else goto <D.20512>;
        <D.20512>:
      }
      goto <D.22385>;
      <D.22342>:
      if (etype == 32768) goto <D.22386>; else goto <D.22387>;
      <D.22386>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.22167 = desc >> 16;
        D.22388 = (int) D.22167;
        offset = D.22388 & 255;
        D.22170 = desc >> 24;
        num_refs = (int) D.22170;
        e_start = start + 16;
        D.22343 = MEM[(struct MonoArray *)start].max_length;
        el_size.151 = (unsigned int) el_size;
        D.22345 = D.22343 * el_size.151;
        e_end = e_start + D.22345;
        goto <D.20524>;
        <D.20523>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.152 = (unsigned int) offset;
          D.22390 = offset.152 * 4;
          p = p + D.22390;
          i = 0;
          goto <D.20521>;
          <D.20520>:
          {
            char * __target;

            D.22391 = MEM[(char * *)p];
            i.153 = (sizetype) i;
            __target = D.22391 + i.153;
            if (__target != 0B) goto <D.22393>; else goto <D.22394>;
            <D.22393>:
            D.22395 = is_valid_object_pointer (__target);
            D.22396 = D.22395 == 0;
            D.22397 = (long int) D.22396;
            D.22398 = __builtin_expect (D.22397, 0);
            if (D.22398 != 0) goto <D.22399>; else goto <D.22400>;
            <D.22399>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "is_valid_object_pointer (__target)");
            <D.22400>:
            D.22401 = sgen_ptr_in_nursery (__target);
            if (D.22401 != 0) goto <D.22402>; else goto <D.22403>;
            <D.22402>:
            D.22404 = MEM[(mword *)__target];
            D.22405 = D.22404 & 2;
            D.22406 = D.22405 == 0;
            D.22407 = (long int) D.22406;
            D.22408 = __builtin_expect (D.22407, 0);
            if (D.22408 != 0) goto <D.22409>; else goto <D.22410>;
            <D.22409>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.22410>:
            goto <D.22411>;
            <D.22403>:
            D.22412 = sgen_los_is_valid_object (__target);
            if (D.22412 != 0) goto <D.22413>; else goto <D.22414>;
            <D.22413>:
            D.22415 = sgen_los_object_is_pinned (__target);
            D.22416 = D.22415 == 0;
            D.22417 = (long int) D.22416;
            D.22418 = __builtin_expect (D.22417, 0);
            if (D.22418 != 0) goto <D.22419>; else goto <D.22420>;
            <D.22419>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
            <D.22420>:
            goto <D.22421>;
            <D.22414>:
            D.22201 = major_collector.is_valid_object;
            D.22422 = D.22201 (__target);
            if (D.22422 != 0) goto <D.22423>; else goto <D.22424>;
            <D.22423>:
            D.22157 = major_collector.is_object_live;
            D.22425 = D.22157 (__target);
            D.22426 = D.22425 == 0;
            D.22427 = (long int) D.22426;
            D.22428 = __builtin_expect (D.22427, 0);
            if (D.22428 != 0) goto <D.22429>; else goto <D.22430>;
            <D.22429>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
            <D.22430>:
            goto <D.22431>;
            <D.22424>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
            <D.22431>:
            <D.22421>:
            <D.22411>:
            <D.22394>:
          }
          i = i + 1;
          <D.20521>:
          if (i < num_refs) goto <D.20520>; else goto <D.20522>;
          <D.20522>:
          el_size.154 = (sizetype) el_size;
          e_start = e_start + el_size.154;
        }
        <D.20524>:
        if (e_start < e_end) goto <D.20523>; else goto <D.20525>;
        <D.20525>:
      }
      goto <D.22433>;
      <D.22387>:
      if (etype == 49152) goto <D.22434>; else goto <D.22435>;
      <D.22434>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.22343 = MEM[(struct MonoArray *)start].max_length;
        el_size.151 = (unsigned int) el_size;
        D.22345 = D.22343 * el_size.151;
        e_end = e_start + D.22345;
        goto <D.20535>;
        <D.20534>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.20532>;
          <D.20531>:
          D.22436 = _bmap & 1;
          if (D.22436 != 0) goto <D.22437>; else goto <D.22438>;
          <D.22437>:
          {
            char * __target;

            __target = MEM[(char * *)p];
            if (__target != 0B) goto <D.22439>; else goto <D.22440>;
            <D.22439>:
            D.22441 = is_valid_object_pointer (__target);
            D.22442 = D.22441 == 0;
            D.22443 = (long int) D.22442;
            D.22444 = __builtin_expect (D.22443, 0);
            if (D.22444 != 0) goto <D.22445>; else goto <D.22446>;
            <D.22445>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "is_valid_object_pointer (__target)");
            <D.22446>:
            D.22447 = sgen_ptr_in_nursery (__target);
            if (D.22447 != 0) goto <D.22448>; else goto <D.22449>;
            <D.22448>:
            D.22450 = MEM[(mword *)__target];
            D.22451 = D.22450 & 2;
            D.22452 = D.22451 == 0;
            D.22453 = (long int) D.22452;
            D.22454 = __builtin_expect (D.22453, 0);
            if (D.22454 != 0) goto <D.22455>; else goto <D.22456>;
            <D.22455>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.22456>:
            goto <D.22457>;
            <D.22449>:
            D.22458 = sgen_los_is_valid_object (__target);
            if (D.22458 != 0) goto <D.22459>; else goto <D.22460>;
            <D.22459>:
            D.22461 = sgen_los_object_is_pinned (__target);
            D.22462 = D.22461 == 0;
            D.22463 = (long int) D.22462;
            D.22464 = __builtin_expect (D.22463, 0);
            if (D.22464 != 0) goto <D.22465>; else goto <D.22466>;
            <D.22465>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
            <D.22466>:
            goto <D.22467>;
            <D.22460>:
            D.22201 = major_collector.is_valid_object;
            D.22468 = D.22201 (__target);
            if (D.22468 != 0) goto <D.22469>; else goto <D.22470>;
            <D.22469>:
            D.22157 = major_collector.is_object_live;
            D.22471 = D.22157 (__target);
            D.22472 = D.22471 == 0;
            D.22473 = (long int) D.22472;
            D.22474 = __builtin_expect (D.22473, 0);
            if (D.22474 != 0) goto <D.22475>; else goto <D.22476>;
            <D.22475>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
            <D.22476>:
            goto <D.22477>;
            <D.22470>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
            <D.22477>:
            <D.22467>:
            <D.22457>:
            <D.22440>:
          }
          <D.22438>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.20532>:
          if (_bmap != 0) goto <D.20531>; else goto <D.20533>;
          <D.20533>:
          el_size.154 = (sizetype) el_size;
          e_start = e_start + el_size.154;
        }
        <D.20535>:
        if (e_start < e_end) goto <D.20534>; else goto <D.20536>;
        <D.20536>:
      }
      <D.22435>:
      <D.22433>:
      <D.22385>:
    }
    <D.22337>:
    goto <D.20493>;
    <D.20537>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.20542>;
      <D.20541>:
      D.22478 = _bmap & 1;
      if (D.22478 != 0) goto <D.22479>; else goto <D.22480>;
      <D.22479>:
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.22481>; else goto <D.22482>;
        <D.22481>:
        D.22483 = is_valid_object_pointer (__target);
        D.22484 = D.22483 == 0;
        D.22485 = (long int) D.22484;
        D.22486 = __builtin_expect (D.22485, 0);
        if (D.22486 != 0) goto <D.22487>; else goto <D.22488>;
        <D.22487>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "is_valid_object_pointer (__target)");
        <D.22488>:
        D.22489 = sgen_ptr_in_nursery (__target);
        if (D.22489 != 0) goto <D.22490>; else goto <D.22491>;
        <D.22490>:
        D.22492 = MEM[(mword *)__target];
        D.22493 = D.22492 & 2;
        D.22494 = D.22493 == 0;
        D.22495 = (long int) D.22494;
        D.22496 = __builtin_expect (D.22495, 0);
        if (D.22496 != 0) goto <D.22497>; else goto <D.22498>;
        <D.22497>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.22498>:
        goto <D.22499>;
        <D.22491>:
        D.22500 = sgen_los_is_valid_object (__target);
        if (D.22500 != 0) goto <D.22501>; else goto <D.22502>;
        <D.22501>:
        D.22503 = sgen_los_object_is_pinned (__target);
        D.22504 = D.22503 == 0;
        D.22505 = (long int) D.22504;
        D.22506 = __builtin_expect (D.22505, 0);
        if (D.22506 != 0) goto <D.22507>; else goto <D.22508>;
        <D.22507>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "sgen_los_object_is_pinned (__target)");
        <D.22508>:
        goto <D.22509>;
        <D.22502>:
        D.22201 = major_collector.is_valid_object;
        D.22510 = D.22201 (__target);
        if (D.22510 != 0) goto <D.22511>; else goto <D.22512>;
        <D.22511>:
        D.22157 = major_collector.is_object_live;
        D.22513 = D.22157 (__target);
        D.22514 = D.22513 == 0;
        D.22515 = (long int) D.22514;
        D.22516 = __builtin_expect (D.22515, 0);
        if (D.22516 != 0) goto <D.22517>; else goto <D.22518>;
        <D.22517>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "major_collector.is_object_live (__target)");
        <D.22518>:
        goto <D.22519>;
        <D.22512>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 85);
        <D.22519>:
        <D.22509>:
        <D.22499>:
        <D.22482>:
      }
      <D.22480>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.20542>:
      if (_bmap != 0) goto <D.20541>; else goto <D.20543>;
      <D.20543>:
    }
    goto <D.20493>;
    <D.20544>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.22520 = *bitmap_data;
      D.22521 = D.22520 + 4294967295;
      bwords = (int) D.22521;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.22522>; else goto <D.22523>;
      <D.22522>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.22524 = myobj->vtable;
        D.22525 = D.22524->klass;
        D.22526 = D.22525->name_space;
        D.22524 = myobj->vtable;
        D.22525 = D.22524->klass;
        D.22527 = D.22525->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.22526, D.22527);
      }
      <D.22523>:
      goto <D.20556>;
      <D.20555>:
      {
        gsize _bmap;

        bitmap_data.155 = bitmap_data;
        bitmap_data = bitmap_data.155 + 4;
        _bmap = *bitmap_data.155;
        _objptr = start_run;
        goto <D.20553>;
        <D.20552>:
        D.22529 = _bmap & 1;
        if (D.22529 != 0) goto <D.22530>; else goto <D.22531>;
        <D.22530>:
        {
          char * __target;

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.22532>; else goto <D.22533>;
          <D.22532>:
          D.22534 = is_valid_object_pointer (__target);
          D.22535 = D.22534 == 0;
          D.22536 = (long int) D.22535;
          D.22537 = __builtin_expect (D.22536, 0);
          if (D.22537 != 0) goto <D.22538>; else goto <D.22539>;
          <D.22538>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "is_valid_object_pointer (__target)");
          <D.22539>:
          D.22540 = sgen_ptr_in_nursery (__target);
          if (D.22540 != 0) goto <D.22541>; else goto <D.22542>;
          <D.22541>:
          D.22543 = MEM[(mword *)__target];
          D.22544 = D.22543 & 2;
          D.22545 = D.22544 == 0;
          D.22546 = (long int) D.22545;
          D.22547 = __builtin_expect (D.22546, 0);
          if (D.22547 != 0) goto <D.22548>; else goto <D.22549>;
          <D.22548>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.22549>:
          goto <D.22550>;
          <D.22542>:
          D.22551 = sgen_los_is_valid_object (__target);
          if (D.22551 != 0) goto <D.22552>; else goto <D.22553>;
          <D.22552>:
          D.22554 = sgen_los_object_is_pinned (__target);
          D.22555 = D.22554 == 0;
          D.22556 = (long int) D.22555;
          D.22557 = __builtin_expect (D.22556, 0);
          if (D.22557 != 0) goto <D.22558>; else goto <D.22559>;
          <D.22558>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "sgen_los_object_is_pinned (__target)");
          <D.22559>:
          goto <D.22560>;
          <D.22553>:
          D.22201 = major_collector.is_valid_object;
          D.22561 = D.22201 (__target);
          if (D.22561 != 0) goto <D.22562>; else goto <D.22563>;
          <D.22562>:
          D.22157 = major_collector.is_object_live;
          D.22564 = D.22157 (__target);
          D.22565 = D.22564 == 0;
          D.22566 = (long int) D.22565;
          D.22567 = __builtin_expect (D.22566, 0);
          if (D.22567 != 0) goto <D.22568>; else goto <D.22569>;
          <D.22568>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "major_collector.is_object_live (__target)");
          <D.22569>:
          goto <D.22570>;
          <D.22563>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 93);
          <D.22570>:
          <D.22560>:
          <D.22550>:
          <D.22533>:
        }
        <D.22531>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.20553>:
        if (_bmap != 0) goto <D.20552>; else goto <D.20554>;
        <D.20554>:
        start_run = start_run + 128;
      }
      <D.20556>:
      bwords.156 = bwords;
      bwords = bwords.156 + -1;
      if (bwords.156 > 0) goto <D.20555>; else goto <D.20557>;
      <D.20557>:
    }
    goto <D.20493>;
    <D.20558>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.22572 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.22572);
      mbitmap_data.157 = mbitmap_data;
      mbitmap_data = mbitmap_data.157 + 4;
      D.22574 = *mbitmap_data.157;
      D.22575 = D.22574 + 4294967295;
      mbwords = (int) D.22575;
      D.22576 = vt->klass;
      el_size = mono_array_element_size (D.22576);
      e_start = start + 16;
      D.22343 = MEM[(struct MonoArray *)start].max_length;
      el_size.158 = (unsigned int) el_size;
      D.22578 = D.22343 * el_size.158;
      e_end = e_start + D.22578;
      if (0 != 0) goto <D.22579>; else goto <D.22580>;
      <D.22579>:
      D.22572 = vt->desc;
      D.22576 = vt->klass;
      D.22581 = D.22576->name_space;
      D.22576 = vt->klass;
      D.22582 = D.22576->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.22572, D.22581, D.22582);
      <D.22580>:
      goto <D.20577>;
      <D.20576>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

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

          bitmap_data.159 = bitmap_data;
          bitmap_data = bitmap_data.159 + 4;
          _bmap = *bitmap_data.159;
          start_run = _objptr;
          goto <D.20571>;
          <D.20570>:
          D.22584 = _bmap & 1;
          if (D.22584 != 0) goto <D.22585>; else goto <D.22586>;
          <D.22585>:
          {
            char * __target;

            __target = MEM[(char * *)_objptr];
            if (__target != 0B) goto <D.22587>; else goto <D.22588>;
            <D.22587>:
            D.22589 = is_valid_object_pointer (__target);
            D.22590 = D.22589 == 0;
            D.22591 = (long int) D.22590;
            D.22592 = __builtin_expect (D.22591, 0);
            if (D.22592 != 0) goto <D.22593>; else goto <D.22594>;
            <D.22593>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "is_valid_object_pointer (__target)");
            <D.22594>:
            D.22595 = sgen_ptr_in_nursery (__target);
            if (D.22595 != 0) goto <D.22596>; else goto <D.22597>;
            <D.22596>:
            D.22598 = MEM[(mword *)__target];
            D.22599 = D.22598 & 2;
            D.22600 = D.22599 == 0;
            D.22601 = (long int) D.22600;
            D.22602 = __builtin_expect (D.22601, 0);
            if (D.22602 != 0) goto <D.22603>; else goto <D.22604>;
            <D.22603>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.22604>:
            goto <D.22605>;
            <D.22597>:
            D.22606 = sgen_los_is_valid_object (__target);
            if (D.22606 != 0) goto <D.22607>; else goto <D.22608>;
            <D.22607>:
            D.22609 = sgen_los_object_is_pinned (__target);
            D.22610 = D.22609 == 0;
            D.22611 = (long int) D.22610;
            D.22612 = __builtin_expect (D.22611, 0);
            if (D.22612 != 0) goto <D.22613>; else goto <D.22614>;
            <D.22613>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "sgen_los_object_is_pinned (__target)");
            <D.22614>:
            goto <D.22615>;
            <D.22608>:
            D.22201 = major_collector.is_valid_object;
            D.22616 = D.22201 (__target);
            if (D.22616 != 0) goto <D.22617>; else goto <D.22618>;
            <D.22617>:
            D.22157 = major_collector.is_object_live;
            D.22619 = D.22157 (__target);
            D.22620 = D.22619 == 0;
            D.22621 = (long int) D.22620;
            D.22622 = __builtin_expect (D.22621, 0);
            if (D.22622 != 0) goto <D.22623>; else goto <D.22624>;
            <D.22623>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "major_collector.is_object_live (__target)");
            <D.22624>:
            goto <D.22625>;
            <D.22618>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 102);
            <D.22625>:
            <D.22615>:
            <D.22605>:
            <D.22588>:
          }
          <D.22586>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.20571>:
          if (_bmap != 0) goto <D.20570>; else goto <D.20572>;
          <D.20572>:
          _objptr = start_run + 128;
        }
        <D.20574>:
        bwords.160 = bwords;
        bwords = bwords.160 + 4294967295;
        if (bwords.160 != 0) goto <D.20573>; else goto <D.20575>;
        <D.20575>:
        el_size.161 = (sizetype) el_size;
        e_start = e_start + el_size.161;
      }
      <D.20577>:
      if (e_start < e_end) goto <D.20576>; else goto <D.20578>;
      <D.20578>:
    }
    goto <D.20493>;
    <D.20579>:
    goto <D.20493>;
    <D.20580>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.20493>:
  }
}


sgen_check_nursery_objects_pinned (gboolean pinned)
{
  struct GCMemSection * nursery_section.162;
  char * D.22631;
  char * D.22632;
  void * pinned.163;

  sgen_clear_nursery_fragments ();
  nursery_section.162 = nursery_section;
  D.22631 = nursery_section.162->data;
  nursery_section.162 = nursery_section;
  D.22632 = nursery_section.162->end_data;
  pinned.163 = (void *) pinned;
  sgen_scan_area_with_callback (D.22631, D.22632, check_nursery_objects_pinned_callback, pinned.163, 0);
}


check_nursery_objects_pinned_callback (char * obj, size_t size, void * data)
{
  int iftmp.164;
  unsigned int D.22637;
  unsigned int D.22638;
  unsigned int D.22640;
  _Bool D.22642;
  long int D.22643;
  long int D.22644;
  unsigned int D.22649;
  _Bool D.22650;
  long int D.22651;
  long int D.22652;
  _Bool D.22656;
  long int D.22657;
  long int D.22658;
  gboolean pinned;

  pinned = (gboolean) data;
  D.22637 = MEM[(mword *)obj];
  D.22638 = D.22637 & 1;
  if (D.22638 != 0) goto <D.22639>; else goto <D.22635>;
  <D.22639>:
  D.22637 = MEM[(mword *)obj];
  D.22640 = D.22637 & 4294967292;
  if (D.22640 != 0) goto <D.22641>; else goto <D.22635>;
  <D.22641>:
  iftmp.164 = 1;
  goto <D.22636>;
  <D.22635>:
  iftmp.164 = 0;
  <D.22636>:
  D.22642 = iftmp.164 != 0;
  D.22643 = (long int) D.22642;
  D.22644 = __builtin_expect (D.22643, 0);
  if (D.22644 != 0) goto <D.22645>; else goto <D.22646>;
  <D.22645>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 575, "!SGEN_OBJECT_IS_FORWARDED (obj)");
  <D.22646>:
  if (pinned != 0) goto <D.22647>; else goto <D.22648>;
  <D.22647>:
  D.22637 = MEM[(mword *)obj];
  D.22649 = D.22637 & 2;
  D.22650 = D.22649 == 0;
  D.22651 = (long int) D.22650;
  D.22652 = __builtin_expect (D.22651, 0);
  if (D.22652 != 0) goto <D.22653>; else goto <D.22654>;
  <D.22653>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 577, "SGEN_OBJECT_IS_PINNED (obj)");
  <D.22654>:
  goto <D.22655>;
  <D.22648>:
  D.22637 = MEM[(mword *)obj];
  D.22649 = D.22637 & 2;
  D.22656 = D.22649 != 0;
  D.22657 = (long int) D.22656;
  D.22658 = __builtin_expect (D.22657, 0);
  if (D.22658 != 0) goto <D.22659>; else goto <D.22660>;
  <D.22659>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 579, "!SGEN_OBJECT_IS_PINNED (obj)");
  <D.22660>:
  <D.22655>:
}