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


describe_pointer (char * ptr, gboolean need_setup)
{
  int D.18011;
  char * start.0;
  char * start.1;
  unsigned int D.18018;
  unsigned int D.18019;
  int D.18021;
  int ptr.2;
  int start.3;
  int D.18029;
  gboolean (*<T2c63>) (char *, char * *) D.18031;
  int D.18032;
  struct MonoVTable * (*<T2c7d>) (char *) D.18043;
  gboolean (*<T2be4>) (char *) D.18045;
  int D.18046;
  unsigned int D.18050;
  char * iftmp.4;
  unsigned int D.18054;
  int D.18062;
  struct MonoClass * D.18065;
  const char * D.18066;
  long int desc.5;
  int desc.6;
  const char * D.18069;
  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.18011 = sgen_ptr_in_nursery (ptr);
      if (D.18011 != 0) goto <D.18012>; else goto <D.18013>;
      <D.18012>:
      start.0 = describe_nursery_ptr (ptr, need_setup);
      start = start.0;
      start.1 = start;
      if (start.1 == 0B) goto <D.18016>; else goto <D.18017>;
      <D.18016>:
      return;
      <D.18017>:
      ptr = start;
      D.18018 = MEM[(mword *)ptr];
      D.18019 = D.18018 & 4294967292;
      vtable = (struct MonoVTable *) D.18019;
      goto <D.18020>;
      <D.18013>:
      D.18021 = sgen_ptr_is_in_los (ptr, &start);
      if (D.18021 != 0) goto <D.18022>; else goto <D.18023>;
      <D.18022>:
      start.1 = start;
      if (ptr == start.1) goto <D.18024>; else goto <D.18025>;
      <D.18024>:
      start.1 = start;
      printf ("Pointer is the start of object %p in LOS space.\n", start.1);
      goto <D.18026>;
      <D.18025>:
      ptr.2 = (int) ptr;
      start.1 = start;
      start.3 = (int) start.1;
      D.18029 = ptr.2 - start.3;
      start.1 = start;
      printf ("Pointer is at offset 0x%x of object %p in LOS space.\n", D.18029, start.1);
      <D.18026>:
      ptr = start;
      mono_sgen_los_describe_pointer (ptr);
      D.18018 = MEM[(mword *)ptr];
      D.18019 = D.18018 & 4294967292;
      vtable = (struct MonoVTable *) D.18019;
      goto <D.18030>;
      <D.18023>:
      D.18031 = major_collector.ptr_is_in_non_pinned_space;
      D.18032 = D.18031 (ptr, &start);
      if (D.18032 != 0) goto <D.18033>; else goto <D.18034>;
      <D.18033>:
      start.1 = start;
      if (ptr == start.1) goto <D.18035>; else goto <D.18036>;
      <D.18035>:
      start.1 = start;
      printf ("Pointer is the start of object %p in oldspace.\n", start.1);
      goto <D.18037>;
      <D.18036>:
      start.1 = start;
      if (start.1 != 0B) goto <D.18038>; else goto <D.18039>;
      <D.18038>:
      ptr.2 = (int) ptr;
      start.1 = start;
      start.3 = (int) start.1;
      D.18029 = ptr.2 - start.3;
      start.1 = start;
      printf ("Pointer is at offset 0x%x of object %p in oldspace.\n", D.18029, start.1);
      goto <D.18040>;
      <D.18039>:
      printf ("Pointer inside oldspace.\n");
      <D.18040>:
      <D.18037>:
      start.1 = start;
      if (start.1 != 0B) goto <D.18041>; else goto <D.18042>;
      <D.18041>:
      ptr = start;
      <D.18042>:
      D.18043 = major_collector.describe_pointer;
      vtable = D.18043 (ptr);
      goto <D.18044>;
      <D.18034>:
      D.18045 = major_collector.obj_is_from_pinned_alloc;
      D.18046 = D.18045 (ptr);
      if (D.18046 != 0) goto <D.18047>; else goto <D.18048>;
      <D.18047>:
      printf ("Pointer is inside a pinned chunk.\n");
      D.18018 = MEM[(mword *)ptr];
      D.18019 = D.18018 & 4294967292;
      vtable = (struct MonoVTable *) D.18019;
      goto <D.18049>;
      <D.18048>:
      printf ("Pointer unknown.\n");
      return;
      <D.18049>:
      <D.18044>:
      <D.18030>:
      <D.18020>:
      D.18018 = MEM[(mword *)ptr];
      D.18050 = D.18018 & 2;
      if (D.18050 != 0) goto <D.18051>; else goto <D.18052>;
      <D.18051>:
      printf ("Object is pinned.\n");
      <D.18052>:
      D.18018 = MEM[(mword *)ptr];
      D.18054 = D.18018 & 1;
      if (D.18054 != 0) goto <D.18055>; else goto <D.18056>;
      <D.18055>:
      D.18018 = MEM[(mword *)ptr];
      D.18019 = D.18018 & 4294967292;
      iftmp.4 = (char *) D.18019;
      goto <D.18057>;
      <D.18056>:
      iftmp.4 = 0B;
      <D.18057>:
      forwarded = iftmp.4;
      if (forwarded != 0B) goto <D.18058>; else goto <D.18059>;
      <D.18058>:
      printf ("Object is forwarded to %p:\n", forwarded);
      ptr = forwarded;
      goto restart;
      <D.18059>:
      printf ("VTable: %p\n", vtable);
      if (vtable == 0B) goto <D.18060>; else goto <D.18061>;
      <D.18060>:
      printf ("VTable is invalid (empty).\n");
      goto bridge;
      <D.18061>:
      D.18062 = sgen_ptr_in_nursery (vtable);
      if (D.18062 != 0) goto <D.18063>; else goto <D.18064>;
      <D.18063>:
      printf ("VTable is invalid (points inside nursery).\n");
      goto bridge;
      <D.18064>:
      D.18065 = vtable->klass;
      D.18066 = D.18065->name;
      printf ("Class: %s\n", D.18066);
      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.18069 = descriptor_types[type];
      printf ("Descriptor type: %d (%s)\n", type, D.18069);
      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.18078;
  char * * D.18079;
  char * D.18080;
  int valid_nursery_object_count.10;
  unsigned int D.18086;
  char * D.18087;
  int gc_debug_level.11;
  _Bool D.18089;
  long int D.18090;
  long int D.18091;
  struct FILE * gc_debug_file.12;
  char * D.18095;
  int ptr.13;
  int obj.14;
  int D.18105;
  int i;

  if (need_setup != 0) goto <D.18074>; else goto <D.18075>;
  <D.18074>:
  setup_valid_nursery_objects ();
  <D.18075>:
  i = 0;
  goto <D.17732>;
  <D.17731>:
  valid_nursery_objects.8 = valid_nursery_objects;
  i.9 = (unsigned int) i;
  D.18078 = i.9 * 4;
  D.18079 = valid_nursery_objects.8 + D.18078;
  D.18080 = *D.18079;
  if (D.18080 >= ptr) goto <D.17730>; else goto <D.18081>;
  <D.18081>:
  i = i + 1;
  <D.17732>:
  valid_nursery_object_count.10 = valid_nursery_object_count;
  if (i < valid_nursery_object_count.10) goto <D.17731>; else goto <D.17730>;
  <D.17730>:
  valid_nursery_object_count.10 = valid_nursery_object_count;
  if (i >= valid_nursery_object_count.10) goto <D.18083>; else goto <D.18085>;
  <D.18085>:
  valid_nursery_objects.8 = valid_nursery_objects;
  i.9 = (unsigned int) i;
  D.18078 = i.9 * 4;
  D.18079 = valid_nursery_objects.8 + D.18078;
  D.18080 = *D.18079;
  valid_nursery_objects.8 = valid_nursery_objects;
  i.9 = (unsigned int) i;
  D.18078 = i.9 * 4;
  D.18079 = valid_nursery_objects.8 + D.18078;
  D.18080 = *D.18079;
  D.18086 = sgen_safe_object_get_size (D.18080);
  D.18087 = D.18080 + D.18086;
  if (D.18087 < ptr) goto <D.18083>; else goto <D.18084>;
  <D.18083>:
  gc_debug_level.11 = gc_debug_level;
  D.18089 = gc_debug_level.11 >= 0;
  D.18090 = (long int) D.18089;
  D.18091 = __builtin_expect (D.18090, 0);
  if (D.18091 != 0) goto <D.18092>; else goto <D.18093>;
  <D.18092>:
  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.18093>:
  D.18095 = 0B;
  return D.18095;
  <D.18084>:
  {
    char * obj;

    valid_nursery_objects.8 = valid_nursery_objects;
    i.9 = (unsigned int) i;
    D.18078 = i.9 * 4;
    D.18079 = valid_nursery_objects.8 + D.18078;
    obj = *D.18079;
    if (obj == ptr) goto <D.18096>; else goto <D.18097>;
    <D.18096>:
    gc_debug_level.11 = gc_debug_level;
    D.18089 = gc_debug_level.11 >= 0;
    D.18090 = (long int) D.18089;
    D.18091 = __builtin_expect (D.18090, 0);
    if (D.18091 != 0) goto <D.18098>; else goto <D.18099>;
    <D.18098>:
    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.18099>:
    goto <D.18100>;
    <D.18097>:
    gc_debug_level.11 = gc_debug_level;
    D.18089 = gc_debug_level.11 >= 0;
    D.18090 = (long int) D.18089;
    D.18091 = __builtin_expect (D.18090, 0);
    if (D.18091 != 0) goto <D.18101>; else goto <D.18102>;
    <D.18101>:
    gc_debug_file.12 = gc_debug_file;
    ptr.13 = (int) ptr;
    obj.14 = (int) obj;
    D.18105 = ptr.13 - obj.14;
    fprintf (gc_debug_file.12, "nursery-ptr (interior-ptr offset %td)\n\n", D.18105);
    gc_debug_file.12 = gc_debug_file;
    fflush (gc_debug_file.12);
    <D.18102>:
    <D.18100>:
    D.18095 = obj;
    return D.18095;
  }
}


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.18114;
  char * D.18115;

  valid_nursery_objects.15 = valid_nursery_objects;
  if (valid_nursery_objects.15 == 0B) goto <D.18108>; else goto <D.18109>;
  <D.18108>:
  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.18109>:
  valid_nursery_object_count = 0;
  nursery_section.19 = nursery_section;
  D.18114 = nursery_section.19->data;
  nursery_section.19 = nursery_section;
  D.18115 = nursery_section.19->end_data;
  sgen_scan_area_with_callback (D.18114, D.18115, 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.18121;
  char * * D.18122;

  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.18121 = valid_nursery_object_count.24 * 4;
  D.18122 = valid_nursery_objects.20 + D.18121;
  *D.18122 = object;
}


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

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


sgen_ptr_in_nursery (void * p)
{
  gboolean D.18125;
  int sgen_nursery_bits.25;
  int D.18127;
  int D.18128;
  unsigned int D.18129;
  unsigned int p.26;
  unsigned int D.18131;
  char * sgen_nursery_start.27;
  unsigned int sgen_nursery_start.28;
  _Bool D.18134;

  sgen_nursery_bits.25 = sgen_nursery_bits;
  D.18127 = 1 << sgen_nursery_bits.25;
  D.18128 = -D.18127;
  D.18129 = (unsigned int) D.18128;
  p.26 = (unsigned int) p;
  D.18131 = D.18129 & p.26;
  sgen_nursery_start.27 = sgen_nursery_start;
  sgen_nursery_start.28 = (unsigned int) sgen_nursery_start.27;
  D.18134 = D.18131 == sgen_nursery_start.28;
  D.18125 = (gboolean) D.18134;
  return D.18125;
}


sgen_safe_object_get_size (struct MonoObject * obj)
{
  char * iftmp.29;
  unsigned int D.18137;
  unsigned int D.18138;
  unsigned int D.18141;
  guint D.18145;
  struct MonoVTable * D.18146;
  char * forwarded;

  D.18137 = MEM[(mword *)obj];
  D.18138 = D.18137 & 1;
  if (D.18138 != 0) goto <D.18139>; else goto <D.18140>;
  <D.18139>:
  D.18137 = MEM[(mword *)obj];
  D.18141 = D.18137 & 4294967292;
  iftmp.29 = (char *) D.18141;
  goto <D.18142>;
  <D.18140>:
  iftmp.29 = 0B;
  <D.18142>:
  forwarded = iftmp.29;
  if (forwarded != 0B) goto <D.18143>; else goto <D.18144>;
  <D.18143>:
  obj = forwarded;
  <D.18144>:
  D.18137 = MEM[(mword *)obj];
  D.18141 = D.18137 & 4294967292;
  D.18146 = (struct MonoVTable *) D.18141;
  D.18145 = sgen_par_object_get_size (D.18146, obj);
  return D.18145;
}


sgen_par_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  void * D.18148;
  unsigned int D.18149;
  guint D.18154;
  int D.18155;
  int D.18156;
  unsigned int D.18157;
  unsigned int D.18160;
  int D.18161;
  unsigned int D.18162;
  unsigned int element_size.30;
  unsigned int D.18164;
  unsigned int D.18165;
  struct MonoClass * D.18168;
  unsigned char D.18169;
  unsigned int D.18170;
  unsigned int D.18171;
  mword descr;
  mword type;

  D.18148 = vtable->gc_descr;
  descr = (mword) D.18148;
  type = descr & 7;
  D.18149 = type + 4294967295;
  if (D.18149 <= 1) goto <D.18150>; else goto <D.18151>;
  <D.18150>:
  {
    mword size;

    size = descr & 65528;
    if (size == 0) goto <D.18152>; else goto <D.18153>;
    <D.18152>:
    D.18155 = MEM[(struct MonoString *)o].length;
    D.18156 = D.18155 * 2;
    D.18157 = (unsigned int) D.18156;
    D.18154 = D.18157 + 14;
    return D.18154;
    <D.18153>:
    D.18154 = size;
    return D.18154;
  }
  <D.18151>:
  if (type == 4) goto <D.18158>; else goto <D.18159>;
  <D.18158>:
  {
    int element_size;
    struct MonoArray * array;
    size_t size;

    D.18160 = descr >> 3;
    D.18161 = (int) D.18160;
    element_size = D.18161 & 1023;
    array = o;
    D.18162 = array->max_length;
    element_size.30 = (unsigned int) element_size;
    D.18164 = D.18162 * element_size.30;
    size = D.18164 + 16;
    D.18165 = descr & 8192;
    if (D.18165 != 0) goto <D.18166>; else goto <D.18167>;
    <D.18166>:
    size = size + 3;
    size = size & 4294967292;
    D.18168 = vtable->klass;
    D.18169 = D.18168->rank;
    D.18170 = (unsigned int) D.18169;
    D.18171 = D.18170 * 8;
    size = D.18171 + size;
    <D.18167>:
    D.18154 = size;
    return D.18154;
  }
  <D.18159>:
  D.18154 = slow_object_get_size (vtable, o);
  return D.18154;
}


slow_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  struct MonoClass * D.18173;
  guint D.18176;
  int D.18177;
  int D.18178;
  unsigned int D.18179;
  unsigned char D.18180;
  int D.18183;
  unsigned int D.18184;
  unsigned int D.18185;
  unsigned int D.18186;
  struct MonoArrayBounds * D.18187;
  _Bool D.18188;
  long int D.18189;
  long int D.18190;
  unsigned int D.18193;
  unsigned int D.18194;
  int D.18195;
  struct MonoClass * klass;

  klass = vtable->klass;
  D.18173 = mono_defaults.string_class;
  if (D.18173 == klass) goto <D.18174>; else goto <D.18175>;
  <D.18174>:
  D.18177 = MEM[(struct MonoString *)o].length;
  D.18178 = D.18177 * 2;
  D.18179 = (unsigned int) D.18178;
  D.18176 = D.18179 + 14;
  return D.18176;
  <D.18175>:
  D.18180 = klass->rank;
  if (D.18180 != 0) goto <D.18181>; else goto <D.18182>;
  <D.18181>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.18183 = klass->sizes.element_size;
    D.18184 = (unsigned int) D.18183;
    D.18185 = array->max_length;
    D.18186 = D.18184 * D.18185;
    size = D.18186 + 16;
    D.18187 = array->bounds;
    D.18188 = D.18187 != 0B;
    D.18189 = (long int) D.18188;
    D.18190 = __builtin_expect (D.18189, 0);
    if (D.18190 != 0) goto <D.18191>; else goto <D.18192>;
    <D.18191>:
    size = size + 3;
    size = size & 4294967292;
    D.18180 = klass->rank;
    D.18193 = (unsigned int) D.18180;
    D.18194 = D.18193 * 8;
    size = D.18194 + size;
    <D.18192>:
    D.18176 = size;
    return D.18176;
  }
  <D.18182>:
  D.18195 = klass->instance_size;
  D.18176 = (guint) D.18195;
  return D.18176;
}


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

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


sgen_check_consistency ()
{
  int gc_debug_level.31;
  _Bool D.18200;
  long int D.18201;
  long int D.18202;
  struct FILE * gc_debug_file.32;
  void (*<T2c3e>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.18206;
  int missing_remsets.33;
  _Bool D.18212;
  long int D.18213;
  long int D.18214;

  missing_remsets = 0;
  gc_debug_level.31 = gc_debug_level;
  D.18200 = gc_debug_level.31 > 0;
  D.18201 = (long int) D.18200;
  D.18202 = __builtin_expect (D.18201, 0);
  if (D.18202 != 0) goto <D.18203>; else goto <D.18204>;
  <D.18203>:
  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.18204>:
  D.18206 = major_collector.iterate_objects;
  D.18206 (1, 1, check_consistency_callback, 0B);
  sgen_los_iterate_objects (check_consistency_callback, 0B);
  gc_debug_level.31 = gc_debug_level;
  D.18200 = gc_debug_level.31 > 0;
  D.18201 = (long int) D.18200;
  D.18202 = __builtin_expect (D.18201, 0);
  if (D.18202 != 0) goto <D.18207>; else goto <D.18208>;
  <D.18207>:
  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.18208>:
  if (1 != 0) goto <D.18209>; else goto <D.18210>;
  <D.18209>:
  missing_remsets.33 = missing_remsets;
  D.18212 = missing_remsets.33 != 0;
  D.18213 = (long int) D.18212;
  D.18214 = __builtin_expect (D.18213, 0);
  if (D.18214 != 0) goto <D.18215>; else goto <D.18216>;
  <D.18215>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 204, "!missing_remsets");
  <D.18216>:
  <D.18210>:
}


check_consistency_callback (char * start, size_t size, void * dummy)
{
  unsigned int D.18217;
  unsigned int D.18218;
  struct FILE * gc_debug_file.34;
  struct MonoClass * D.18222;
  const char * D.18223;
  unsigned int D.18224;
  unsigned int D.18225;
  unsigned int D.18228;
  unsigned int D.18229;
  unsigned int D.18230;
  unsigned int D.18231;
  unsigned int D.18232;
  void * D.18233;
  int D.18236;
  struct SgenRemeberedSet * D.18239;
  gboolean (*<T2be4>) (char *) D.18240;
  int D.18241;
  int gc_debug_level.35;
  _Bool D.18245;
  long int D.18246;
  long int D.18247;
  int _objptr.36;
  int start.37;
  int D.18252;
  struct MonoVTable * D.18253;
  struct MonoClass * D.18254;
  const char * D.18255;
  const char * D.18256;
  unsigned int D.18257;
  unsigned int D.18258;
  int D.18263;
  struct SgenRemeberedSet * D.18266;
  gboolean (*<T2be4>) (char *) D.18267;
  int D.18268;
  unsigned int _index.38;
  unsigned int D.18276;
  int D.18277;
  void * D.18278;
  int D.18281;
  struct SgenRemeberedSet * D.18284;
  gboolean (*<T2be4>) (char *) D.18285;
  int D.18286;
  int _objptr.39;
  int D.18292;
  unsigned int D.18293;
  unsigned int D.18294;
  unsigned int _index.40;
  unsigned int D.18298;
  int D.18299;
  int D.18302;
  struct SgenRemeberedSet * D.18305;
  gboolean (*<T2be4>) (char *) D.18306;
  int D.18307;
  unsigned int D.18314;
  unsigned int D.18317;
  int D.18318;
  int desc.41;
  unsigned int D.18322;
  unsigned int el_size.42;
  unsigned int D.18324;
  void * D.18325;
  int D.18328;
  struct SgenRemeberedSet * D.18331;
  gboolean (*<T2be4>) (char *) D.18332;
  int D.18333;
  int p.43;
  int D.18339;
  unsigned int D.18340;
  unsigned int D.18341;
  int D.18347;
  unsigned int offset.44;
  unsigned int D.18349;
  unsigned int i.45;
  unsigned int D.18351;
  void * * D.18352;
  void * D.18353;
  int D.18356;
  struct SgenRemeberedSet * D.18359;
  gboolean (*<T2be4>) (char *) D.18360;
  char * D.18361;
  int D.18362;
  int D.18367;
  int D.18368;
  unsigned int D.18369;
  unsigned int D.18370;
  sizetype el_size.46;
  unsigned int D.18377;
  void * D.18380;
  int D.18383;
  struct SgenRemeberedSet * D.18386;
  gboolean (*<T2be4>) (char *) D.18387;
  int D.18388;
  int p.47;
  int D.18394;
  unsigned int D.18395;
  unsigned int D.18396;
  unsigned int D.18399;
  void * D.18402;
  int D.18405;
  struct SgenRemeberedSet * D.18408;
  gboolean (*<T2be4>) (char *) D.18409;
  int D.18410;
  int _objptr.48;
  int D.18416;
  unsigned int D.18417;
  unsigned int D.18418;
  unsigned int D.18421;
  unsigned int D.18422;
  struct MonoVTable * D.18425;
  struct MonoClass * D.18426;
  const char * D.18427;
  const char * D.18428;
  gsize * bitmap_data.49;
  unsigned int D.18430;
  void * D.18433;
  int D.18436;
  struct SgenRemeberedSet * D.18439;
  gboolean (*<T2be4>) (char *) D.18440;
  int D.18441;
  int _objptr.50;
  int D.18447;
  unsigned int D.18448;
  unsigned int D.18449;
  int bwords.51;
  unsigned int D.18453;
  gsize * mbitmap_data.52;
  unsigned int D.18455;
  unsigned int D.18456;
  struct MonoClass * D.18457;
  unsigned int el_size.53;
  unsigned int D.18459;
  const char * D.18462;
  const char * D.18463;
  gsize * bitmap_data.54;
  unsigned int D.18465;
  void * D.18468;
  int D.18471;
  struct SgenRemeberedSet * D.18474;
  gboolean (*<T2be4>) (char *) D.18475;
  int D.18476;
  int _objptr.55;
  int D.18482;
  unsigned int D.18483;
  unsigned int D.18484;
  unsigned int bwords.56;
  sizetype el_size.57;
  struct GCVTable * vt;

  D.18217 = MEM[(mword *)start];
  D.18218 = D.18217 & 4294967292;
  vt = (struct GCVTable *) D.18218;
  if (0 != 0) goto <D.18219>; else goto <D.18220>;
  <D.18219>:
  gc_debug_file.34 = gc_debug_file;
  D.18222 = vt->klass;
  D.18223 = D.18222->name;
  fprintf (gc_debug_file.34, "Scanning object %p, vtable: %p (%s)\n", start, vt, D.18223);
  gc_debug_file.34 = gc_debug_file;
  fflush (gc_debug_file.34);
  <D.18220>:
  {
    struct GCVTable * vt;
    mword desc;

    D.18217 = MEM[(mword *)start];
    D.18218 = D.18217 & 4294967292;
    vt = (struct GCVTable *) D.18218;
    desc = vt->desc;
    D.18224 = desc & 7;
    switch (D.18224) <default: <D.17401>, case 1: <D.17316>, case 2: <D.17323>, case 3: <D.17367>, case 4: <D.17331>, case 5: <D.17361>, case 6: <D.17380>, case 7: <D.17400>>
    <D.17316>:
    D.18225 = desc & 4294901760;
    if (D.18225 != 0) goto <D.18226>; else goto <D.18227>;
    <D.18226>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.18228 = desc >> 16;
      D.18229 = D.18228 & 255;
      D.18230 = D.18229 * 4;
      _objptr = _objptr + D.18230;
      D.18231 = desc >> 24;
      D.18232 = D.18231 * 4;
      _objptr_end = _objptr + D.18232;
      D.18233 = *_objptr;
      if (D.18233 != 0B) goto <D.18234>; else goto <D.18235>;
      <D.18234>:
      D.18233 = *_objptr;
      D.18236 = sgen_ptr_in_nursery (D.18233);
      if (D.18236 != 0) goto <D.18237>; else goto <D.18238>;
      <D.18237>:
      D.18239 = sgen_get_remset ();
      D.18240 = D.18239->find_address;
      D.18241 = D.18240 (_objptr);
      if (D.18241 == 0) goto <D.18242>; else goto <D.18243>;
      <D.18242>:
      gc_debug_level.35 = gc_debug_level;
      D.18245 = gc_debug_level.35 >= 0;
      D.18246 = (long int) D.18245;
      D.18247 = __builtin_expect (D.18246, 0);
      if (D.18247 != 0) goto <D.18248>; else goto <D.18249>;
      <D.18248>:
      gc_debug_file.34 = gc_debug_file;
      D.18233 = *_objptr;
      _objptr.36 = (int) _objptr;
      start.37 = (int) start;
      D.18252 = _objptr.36 - start.37;
      D.18253 = MEM[(struct MonoObject *)start].vtable;
      D.18254 = D.18253->klass;
      D.18255 = D.18254->name_space;
      D.18253 = MEM[(struct MonoObject *)start].vtable;
      D.18254 = D.18253->klass;
      D.18256 = D.18254->name;
      fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18233, D.18252, start, D.18255, D.18256);
      gc_debug_file.34 = gc_debug_file;
      fflush (gc_debug_file.34);
      <D.18249>:
      D.18233 = *_objptr;
      D.18257 = MEM[(mword *)D.18233];
      D.18258 = D.18257 & 2;
      if (D.18258 == 0) goto <D.18259>; else goto <D.18260>;
      <D.18259>:
      missing_remsets = 1;
      <D.18260>:
      <D.18243>:
      <D.18238>:
      <D.18235>:
      _objptr = _objptr + 4;
      goto <D.17320>;
      <D.17319>:
      D.18233 = *_objptr;
      if (D.18233 != 0B) goto <D.18261>; else goto <D.18262>;
      <D.18261>:
      D.18233 = *_objptr;
      D.18263 = sgen_ptr_in_nursery (D.18233);
      if (D.18263 != 0) goto <D.18264>; else goto <D.18265>;
      <D.18264>:
      D.18266 = sgen_get_remset ();
      D.18267 = D.18266->find_address;
      D.18268 = D.18267 (_objptr);
      if (D.18268 == 0) goto <D.18269>; else goto <D.18270>;
      <D.18269>:
      gc_debug_level.35 = gc_debug_level;
      D.18245 = gc_debug_level.35 >= 0;
      D.18246 = (long int) D.18245;
      D.18247 = __builtin_expect (D.18246, 0);
      if (D.18247 != 0) goto <D.18271>; else goto <D.18272>;
      <D.18271>:
      gc_debug_file.34 = gc_debug_file;
      D.18233 = *_objptr;
      _objptr.36 = (int) _objptr;
      start.37 = (int) start;
      D.18252 = _objptr.36 - start.37;
      D.18253 = MEM[(struct MonoObject *)start].vtable;
      D.18254 = D.18253->klass;
      D.18255 = D.18254->name_space;
      D.18253 = MEM[(struct MonoObject *)start].vtable;
      D.18254 = D.18253->klass;
      D.18256 = D.18254->name;
      fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18233, D.18252, start, D.18255, D.18256);
      gc_debug_file.34 = gc_debug_file;
      fflush (gc_debug_file.34);
      <D.18272>:
      D.18233 = *_objptr;
      D.18257 = MEM[(mword *)D.18233];
      D.18258 = D.18257 & 2;
      if (D.18258 == 0) goto <D.18273>; else goto <D.18274>;
      <D.18273>:
      missing_remsets = 1;
      <D.18274>:
      <D.18270>:
      <D.18265>:
      <D.18262>:
      _objptr = _objptr + 4;
      <D.17320>:
      if (_objptr < _objptr_end) goto <D.17319>; else goto <D.17321>;
      <D.17321>:
    }
    <D.18227>:
    goto <D.17322>;
    <D.17323>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.38 = (unsigned int) _index;
        D.18276 = _index.38 * 4;
        _objptr = _objptr + D.18276;
        D.18277 = _index + 1;
        _bmap = _bmap >> D.18277;
        D.18278 = *_objptr;
        if (D.18278 != 0B) goto <D.18279>; else goto <D.18280>;
        <D.18279>:
        D.18278 = *_objptr;
        D.18281 = sgen_ptr_in_nursery (D.18278);
        if (D.18281 != 0) goto <D.18282>; else goto <D.18283>;
        <D.18282>:
        D.18284 = sgen_get_remset ();
        D.18285 = D.18284->find_address;
        D.18286 = D.18285 (_objptr);
        if (D.18286 == 0) goto <D.18287>; else goto <D.18288>;
        <D.18287>:
        gc_debug_level.35 = gc_debug_level;
        D.18245 = gc_debug_level.35 >= 0;
        D.18246 = (long int) D.18245;
        D.18247 = __builtin_expect (D.18246, 0);
        if (D.18247 != 0) goto <D.18289>; else goto <D.18290>;
        <D.18289>:
        gc_debug_file.34 = gc_debug_file;
        D.18278 = *_objptr;
        _objptr.39 = (int) _objptr;
        start.37 = (int) start;
        D.18292 = _objptr.39 - start.37;
        D.18253 = MEM[(struct MonoObject *)start].vtable;
        D.18254 = D.18253->klass;
        D.18255 = D.18254->name_space;
        D.18253 = MEM[(struct MonoObject *)start].vtable;
        D.18254 = D.18253->klass;
        D.18256 = D.18254->name;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18278, D.18292, start, D.18255, D.18256);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.18290>:
        D.18278 = *_objptr;
        D.18293 = MEM[(mword *)D.18278];
        D.18294 = D.18293 & 2;
        if (D.18294 == 0) goto <D.18295>; else goto <D.18296>;
        <D.18295>:
        missing_remsets = 1;
        <D.18296>:
        <D.18288>:
        <D.18283>:
        <D.18280>:
        _objptr = _objptr + 4;
      }
      goto <D.17329>;
      <D.17328>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.40 = (unsigned int) _index;
        D.18298 = _index.40 * 4;
        _objptr = _objptr + D.18298;
        D.18299 = _index + 1;
        _bmap = _bmap >> D.18299;
        D.18278 = *_objptr;
        if (D.18278 != 0B) goto <D.18300>; else goto <D.18301>;
        <D.18300>:
        D.18278 = *_objptr;
        D.18302 = sgen_ptr_in_nursery (D.18278);
        if (D.18302 != 0) goto <D.18303>; else goto <D.18304>;
        <D.18303>:
        D.18305 = sgen_get_remset ();
        D.18306 = D.18305->find_address;
        D.18307 = D.18306 (_objptr);
        if (D.18307 == 0) goto <D.18308>; else goto <D.18309>;
        <D.18308>:
        gc_debug_level.35 = gc_debug_level;
        D.18245 = gc_debug_level.35 >= 0;
        D.18246 = (long int) D.18245;
        D.18247 = __builtin_expect (D.18246, 0);
        if (D.18247 != 0) goto <D.18310>; else goto <D.18311>;
        <D.18310>:
        gc_debug_file.34 = gc_debug_file;
        D.18278 = *_objptr;
        _objptr.39 = (int) _objptr;
        start.37 = (int) start;
        D.18292 = _objptr.39 - start.37;
        D.18253 = MEM[(struct MonoObject *)start].vtable;
        D.18254 = D.18253->klass;
        D.18255 = D.18254->name_space;
        D.18253 = MEM[(struct MonoObject *)start].vtable;
        D.18254 = D.18253->klass;
        D.18256 = D.18254->name;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18278, D.18292, start, D.18255, D.18256);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.18311>:
        D.18278 = *_objptr;
        D.18293 = MEM[(mword *)D.18278];
        D.18294 = D.18293 & 2;
        if (D.18294 == 0) goto <D.18312>; else goto <D.18313>;
        <D.18312>:
        missing_remsets = 1;
        <D.18313>:
        <D.18309>:
        <D.18304>:
        <D.18301>:
        _objptr = _objptr + 4;
      }
      <D.17329>:
      if (_bmap != 0) goto <D.17328>; else goto <D.17330>;
      <D.17330>:
    }
    goto <D.17322>;
    <D.17331>:
    D.18314 = desc & 4294950912;
    if (D.18314 != 0) goto <D.18315>; else goto <D.18316>;
    <D.18315>:
    {
      int el_size;
      int etype;

      D.18317 = desc >> 3;
      D.18318 = (int) D.18317;
      el_size = D.18318 & 1023;
      desc.41 = (int) desc;
      etype = desc.41 & 49152;
      if (etype == 16384) goto <D.18320>; else goto <D.18321>;
      <D.18320>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.18322 = MEM[(struct MonoArray *)start].max_length;
        el_size.42 = (unsigned int) el_size;
        D.18324 = D.18322 * el_size.42;
        end_refs = p + D.18324;
        goto <D.17337>;
        <D.17336>:
        D.18325 = *p;
        if (D.18325 != 0B) goto <D.18326>; else goto <D.18327>;
        <D.18326>:
        D.18325 = *p;
        D.18328 = sgen_ptr_in_nursery (D.18325);
        if (D.18328 != 0) goto <D.18329>; else goto <D.18330>;
        <D.18329>:
        D.18331 = sgen_get_remset ();
        D.18332 = D.18331->find_address;
        D.18333 = D.18332 (p);
        if (D.18333 == 0) goto <D.18334>; else goto <D.18335>;
        <D.18334>:
        gc_debug_level.35 = gc_debug_level;
        D.18245 = gc_debug_level.35 >= 0;
        D.18246 = (long int) D.18245;
        D.18247 = __builtin_expect (D.18246, 0);
        if (D.18247 != 0) goto <D.18336>; else goto <D.18337>;
        <D.18336>:
        gc_debug_file.34 = gc_debug_file;
        D.18325 = *p;
        p.43 = (int) p;
        start.37 = (int) start;
        D.18339 = p.43 - start.37;
        D.18253 = MEM[(struct MonoObject *)start].vtable;
        D.18254 = D.18253->klass;
        D.18255 = D.18254->name_space;
        D.18253 = MEM[(struct MonoObject *)start].vtable;
        D.18254 = D.18253->klass;
        D.18256 = D.18254->name;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18325, D.18339, start, D.18255, D.18256);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.18337>:
        D.18325 = *p;
        D.18340 = MEM[(mword *)D.18325];
        D.18341 = D.18340 & 2;
        if (D.18341 == 0) goto <D.18342>; else goto <D.18343>;
        <D.18342>:
        missing_remsets = 1;
        <D.18343>:
        <D.18335>:
        <D.18330>:
        <D.18327>:
        p = p + 4;
        <D.17337>:
        if (p < end_refs) goto <D.17336>; else goto <D.17338>;
        <D.17338>:
      }
      goto <D.18344>;
      <D.18321>:
      if (etype == 32768) goto <D.18345>; else goto <D.18346>;
      <D.18345>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.18228 = desc >> 16;
        D.18347 = (int) D.18228;
        offset = D.18347 & 255;
        D.18231 = desc >> 24;
        num_refs = (int) D.18231;
        e_start = start + 16;
        D.18322 = MEM[(struct MonoArray *)start].max_length;
        el_size.42 = (unsigned int) el_size;
        D.18324 = D.18322 * el_size.42;
        e_end = e_start + D.18324;
        goto <D.17349>;
        <D.17348>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.44 = (unsigned int) offset;
          D.18349 = offset.44 * 4;
          p = p + D.18349;
          i = 0;
          goto <D.17346>;
          <D.17345>:
          i.45 = (unsigned int) i;
          D.18351 = i.45 * 4;
          D.18352 = p + D.18351;
          D.18353 = *D.18352;
          if (D.18353 != 0B) goto <D.18354>; else goto <D.18355>;
          <D.18354>:
          i.45 = (unsigned int) i;
          D.18351 = i.45 * 4;
          D.18352 = p + D.18351;
          D.18353 = *D.18352;
          D.18356 = sgen_ptr_in_nursery (D.18353);
          if (D.18356 != 0) goto <D.18357>; else goto <D.18358>;
          <D.18357>:
          D.18359 = sgen_get_remset ();
          D.18360 = D.18359->find_address;
          i.45 = (unsigned int) i;
          D.18351 = i.45 * 4;
          D.18361 = p + D.18351;
          D.18362 = D.18360 (D.18361);
          if (D.18362 == 0) goto <D.18363>; else goto <D.18364>;
          <D.18363>:
          gc_debug_level.35 = gc_debug_level;
          D.18245 = gc_debug_level.35 >= 0;
          D.18246 = (long int) D.18245;
          D.18247 = __builtin_expect (D.18246, 0);
          if (D.18247 != 0) goto <D.18365>; else goto <D.18366>;
          <D.18365>:
          gc_debug_file.34 = gc_debug_file;
          i.45 = (unsigned int) i;
          D.18351 = i.45 * 4;
          D.18352 = p + D.18351;
          D.18353 = *D.18352;
          i.45 = (unsigned int) i;
          D.18351 = i.45 * 4;
          D.18361 = p + D.18351;
          D.18367 = (int) D.18361;
          start.37 = (int) start;
          D.18368 = D.18367 - start.37;
          D.18253 = MEM[(struct MonoObject *)start].vtable;
          D.18254 = D.18253->klass;
          D.18255 = D.18254->name_space;
          D.18253 = MEM[(struct MonoObject *)start].vtable;
          D.18254 = D.18253->klass;
          D.18256 = D.18254->name;
          fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18353, D.18368, start, D.18255, D.18256);
          gc_debug_file.34 = gc_debug_file;
          fflush (gc_debug_file.34);
          <D.18366>:
          i.45 = (unsigned int) i;
          D.18351 = i.45 * 4;
          D.18352 = p + D.18351;
          D.18353 = *D.18352;
          D.18369 = MEM[(mword *)D.18353];
          D.18370 = D.18369 & 2;
          if (D.18370 == 0) goto <D.18371>; else goto <D.18372>;
          <D.18371>:
          missing_remsets = 1;
          <D.18372>:
          <D.18364>:
          <D.18358>:
          <D.18355>:
          i = i + 1;
          <D.17346>:
          if (i < num_refs) goto <D.17345>; else goto <D.17347>;
          <D.17347>:
          el_size.46 = (sizetype) el_size;
          e_start = e_start + el_size.46;
        }
        <D.17349>:
        if (e_start < e_end) goto <D.17348>; else goto <D.17350>;
        <D.17350>:
      }
      goto <D.18374>;
      <D.18346>:
      if (etype == 49152) goto <D.18375>; else goto <D.18376>;
      <D.18375>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.18322 = MEM[(struct MonoArray *)start].max_length;
        el_size.42 = (unsigned int) el_size;
        D.18324 = D.18322 * el_size.42;
        e_end = e_start + D.18324;
        goto <D.17359>;
        <D.17358>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17356>;
          <D.17355>:
          D.18377 = _bmap & 1;
          if (D.18377 != 0) goto <D.18378>; else goto <D.18379>;
          <D.18378>:
          D.18380 = *p;
          if (D.18380 != 0B) goto <D.18381>; else goto <D.18382>;
          <D.18381>:
          D.18380 = *p;
          D.18383 = sgen_ptr_in_nursery (D.18380);
          if (D.18383 != 0) goto <D.18384>; else goto <D.18385>;
          <D.18384>:
          D.18386 = sgen_get_remset ();
          D.18387 = D.18386->find_address;
          D.18388 = D.18387 (p);
          if (D.18388 == 0) goto <D.18389>; else goto <D.18390>;
          <D.18389>:
          gc_debug_level.35 = gc_debug_level;
          D.18245 = gc_debug_level.35 >= 0;
          D.18246 = (long int) D.18245;
          D.18247 = __builtin_expect (D.18246, 0);
          if (D.18247 != 0) goto <D.18391>; else goto <D.18392>;
          <D.18391>:
          gc_debug_file.34 = gc_debug_file;
          D.18380 = *p;
          p.47 = (int) p;
          start.37 = (int) start;
          D.18394 = p.47 - start.37;
          D.18253 = MEM[(struct MonoObject *)start].vtable;
          D.18254 = D.18253->klass;
          D.18255 = D.18254->name_space;
          D.18253 = MEM[(struct MonoObject *)start].vtable;
          D.18254 = D.18253->klass;
          D.18256 = D.18254->name;
          fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18380, D.18394, start, D.18255, D.18256);
          gc_debug_file.34 = gc_debug_file;
          fflush (gc_debug_file.34);
          <D.18392>:
          D.18380 = *p;
          D.18395 = MEM[(mword *)D.18380];
          D.18396 = D.18395 & 2;
          if (D.18396 == 0) goto <D.18397>; else goto <D.18398>;
          <D.18397>:
          missing_remsets = 1;
          <D.18398>:
          <D.18390>:
          <D.18385>:
          <D.18382>:
          <D.18379>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17356>:
          if (_bmap != 0) goto <D.17355>; else goto <D.17357>;
          <D.17357>:
          el_size.46 = (sizetype) el_size;
          e_start = e_start + el_size.46;
        }
        <D.17359>:
        if (e_start < e_end) goto <D.17358>; else goto <D.17360>;
        <D.17360>:
      }
      <D.18376>:
      <D.18374>:
      <D.18344>:
    }
    <D.18316>:
    goto <D.17322>;
    <D.17361>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17365>;
      <D.17364>:
      D.18399 = _bmap & 1;
      if (D.18399 != 0) goto <D.18400>; else goto <D.18401>;
      <D.18400>:
      D.18402 = *_objptr;
      if (D.18402 != 0B) goto <D.18403>; else goto <D.18404>;
      <D.18403>:
      D.18402 = *_objptr;
      D.18405 = sgen_ptr_in_nursery (D.18402);
      if (D.18405 != 0) goto <D.18406>; else goto <D.18407>;
      <D.18406>:
      D.18408 = sgen_get_remset ();
      D.18409 = D.18408->find_address;
      D.18410 = D.18409 (_objptr);
      if (D.18410 == 0) goto <D.18411>; else goto <D.18412>;
      <D.18411>:
      gc_debug_level.35 = gc_debug_level;
      D.18245 = gc_debug_level.35 >= 0;
      D.18246 = (long int) D.18245;
      D.18247 = __builtin_expect (D.18246, 0);
      if (D.18247 != 0) goto <D.18413>; else goto <D.18414>;
      <D.18413>:
      gc_debug_file.34 = gc_debug_file;
      D.18402 = *_objptr;
      _objptr.48 = (int) _objptr;
      start.37 = (int) start;
      D.18416 = _objptr.48 - start.37;
      D.18253 = MEM[(struct MonoObject *)start].vtable;
      D.18254 = D.18253->klass;
      D.18255 = D.18254->name_space;
      D.18253 = MEM[(struct MonoObject *)start].vtable;
      D.18254 = D.18253->klass;
      D.18256 = D.18254->name;
      fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18402, D.18416, start, D.18255, D.18256);
      gc_debug_file.34 = gc_debug_file;
      fflush (gc_debug_file.34);
      <D.18414>:
      D.18402 = *_objptr;
      D.18417 = MEM[(mword *)D.18402];
      D.18418 = D.18417 & 2;
      if (D.18418 == 0) goto <D.18419>; else goto <D.18420>;
      <D.18419>:
      missing_remsets = 1;
      <D.18420>:
      <D.18412>:
      <D.18407>:
      <D.18404>:
      <D.18401>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17365>:
      if (_bmap != 0) goto <D.17364>; else goto <D.17366>;
      <D.17366>:
    }
    goto <D.17322>;
    <D.17367>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.18421 = *bitmap_data;
      D.18422 = D.18421 + 4294967295;
      bwords = (int) D.18422;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.18423>; else goto <D.18424>;
      <D.18423>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.18425 = myobj->vtable;
        D.18426 = D.18425->klass;
        D.18427 = D.18426->name_space;
        D.18425 = myobj->vtable;
        D.18426 = D.18425->klass;
        D.18428 = D.18426->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18427, D.18428);
      }
      <D.18424>:
      goto <D.17378>;
      <D.17377>:
      {
        gsize _bmap;

        bitmap_data.49 = bitmap_data;
        bitmap_data = bitmap_data.49 + 4;
        _bmap = *bitmap_data.49;
        _objptr = start_run;
        goto <D.17375>;
        <D.17374>:
        D.18430 = _bmap & 1;
        if (D.18430 != 0) goto <D.18431>; else goto <D.18432>;
        <D.18431>:
        D.18433 = *_objptr;
        if (D.18433 != 0B) goto <D.18434>; else goto <D.18435>;
        <D.18434>:
        D.18433 = *_objptr;
        D.18436 = sgen_ptr_in_nursery (D.18433);
        if (D.18436 != 0) goto <D.18437>; else goto <D.18438>;
        <D.18437>:
        D.18439 = sgen_get_remset ();
        D.18440 = D.18439->find_address;
        D.18441 = D.18440 (_objptr);
        if (D.18441 == 0) goto <D.18442>; else goto <D.18443>;
        <D.18442>:
        gc_debug_level.35 = gc_debug_level;
        D.18245 = gc_debug_level.35 >= 0;
        D.18246 = (long int) D.18245;
        D.18247 = __builtin_expect (D.18246, 0);
        if (D.18247 != 0) goto <D.18444>; else goto <D.18445>;
        <D.18444>:
        gc_debug_file.34 = gc_debug_file;
        D.18433 = *_objptr;
        _objptr.50 = (int) _objptr;
        start.37 = (int) start;
        D.18447 = _objptr.50 - start.37;
        D.18253 = MEM[(struct MonoObject *)start].vtable;
        D.18254 = D.18253->klass;
        D.18255 = D.18254->name_space;
        D.18253 = MEM[(struct MonoObject *)start].vtable;
        D.18254 = D.18253->klass;
        D.18256 = D.18254->name;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18433, D.18447, start, D.18255, D.18256);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.18445>:
        D.18433 = *_objptr;
        D.18448 = MEM[(mword *)D.18433];
        D.18449 = D.18448 & 2;
        if (D.18449 == 0) goto <D.18450>; else goto <D.18451>;
        <D.18450>:
        missing_remsets = 1;
        <D.18451>:
        <D.18443>:
        <D.18438>:
        <D.18435>:
        <D.18432>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17375>:
        if (_bmap != 0) goto <D.17374>; else goto <D.17376>;
        <D.17376>:
        start_run = start_run + 128;
      }
      <D.17378>:
      bwords.51 = bwords;
      bwords = bwords.51 + -1;
      if (bwords.51 > 0) goto <D.17377>; else goto <D.17379>;
      <D.17379>:
    }
    goto <D.17322>;
    <D.17380>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.18453 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.18453);
      mbitmap_data.52 = mbitmap_data;
      mbitmap_data = mbitmap_data.52 + 4;
      D.18455 = *mbitmap_data.52;
      D.18456 = D.18455 + 4294967295;
      mbwords = (int) D.18456;
      D.18457 = vt->klass;
      el_size = mono_array_element_size (D.18457);
      e_start = start + 16;
      D.18322 = MEM[(struct MonoArray *)start].max_length;
      el_size.53 = (unsigned int) el_size;
      D.18459 = D.18322 * el_size.53;
      e_end = e_start + D.18459;
      if (0 != 0) goto <D.18460>; else goto <D.18461>;
      <D.18460>:
      D.18453 = vt->desc;
      D.18457 = vt->klass;
      D.18462 = D.18457->name_space;
      D.18457 = vt->klass;
      D.18463 = D.18457->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.18453, D.18462, D.18463);
      <D.18461>:
      goto <D.17398>;
      <D.17397>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.17395>;
        <D.17394>:
        {
          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.17392>;
          <D.17391>:
          D.18465 = _bmap & 1;
          if (D.18465 != 0) goto <D.18466>; else goto <D.18467>;
          <D.18466>:
          D.18468 = *_objptr;
          if (D.18468 != 0B) goto <D.18469>; else goto <D.18470>;
          <D.18469>:
          D.18468 = *_objptr;
          D.18471 = sgen_ptr_in_nursery (D.18468);
          if (D.18471 != 0) goto <D.18472>; else goto <D.18473>;
          <D.18472>:
          D.18474 = sgen_get_remset ();
          D.18475 = D.18474->find_address;
          D.18476 = D.18475 (_objptr);
          if (D.18476 == 0) goto <D.18477>; else goto <D.18478>;
          <D.18477>:
          gc_debug_level.35 = gc_debug_level;
          D.18245 = gc_debug_level.35 >= 0;
          D.18246 = (long int) D.18245;
          D.18247 = __builtin_expect (D.18246, 0);
          if (D.18247 != 0) goto <D.18479>; else goto <D.18480>;
          <D.18479>:
          gc_debug_file.34 = gc_debug_file;
          D.18468 = *_objptr;
          _objptr.55 = (int) _objptr;
          start.37 = (int) start;
          D.18482 = _objptr.55 - start.37;
          D.18253 = MEM[(struct MonoObject *)start].vtable;
          D.18254 = D.18253->klass;
          D.18255 = D.18254->name_space;
          D.18253 = MEM[(struct MonoObject *)start].vtable;
          D.18254 = D.18253->klass;
          D.18256 = D.18254->name;
          fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18468, D.18482, start, D.18255, D.18256);
          gc_debug_file.34 = gc_debug_file;
          fflush (gc_debug_file.34);
          <D.18480>:
          D.18468 = *_objptr;
          D.18483 = MEM[(mword *)D.18468];
          D.18484 = D.18483 & 2;
          if (D.18484 == 0) goto <D.18485>; else goto <D.18486>;
          <D.18485>:
          missing_remsets = 1;
          <D.18486>:
          <D.18478>:
          <D.18473>:
          <D.18470>:
          <D.18467>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17392>:
          if (_bmap != 0) goto <D.17391>; else goto <D.17393>;
          <D.17393>:
          _objptr = start_run + 128;
        }
        <D.17395>:
        bwords.56 = bwords;
        bwords = bwords.56 + 4294967295;
        if (bwords.56 != 0) goto <D.17394>; else goto <D.17396>;
        <D.17396>:
        el_size.57 = (sizetype) el_size;
        e_start = e_start + el_size.57;
      }
      <D.17398>:
      if (e_start < e_end) goto <D.17397>; else goto <D.17399>;
      <D.17399>:
    }
    goto <D.17322>;
    <D.17400>:
    goto <D.17322>;
    <D.17401>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17322>:
  }
}


sgen_check_mod_union_consistency ()
{
  void (*<T2c3e>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.18490;
  int missing_remsets.58;
  _Bool D.18494;
  long int D.18495;
  long int D.18496;

  missing_remsets = 0;
  D.18490 = major_collector.iterate_objects;
  D.18490 (1, 1, check_mod_union_callback, 0B);
  sgen_los_iterate_objects (check_mod_union_callback, 1B);
  if (1 != 0) goto <D.18491>; else goto <D.18492>;
  <D.18491>:
  missing_remsets.58 = missing_remsets;
  D.18494 = missing_remsets.58 != 0;
  D.18495 = (long int) D.18494;
  D.18496 = __builtin_expect (D.18495, 0);
  if (D.18496 != 0) goto <D.18497>; else goto <D.18498>;
  <D.18497>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 258, "!missing_remsets");
  <D.18498>:
  <D.18492>:
}


check_mod_union_callback (char * start, size_t size, void * dummy)
{
  unsigned int D.18499;
  unsigned int D.18500;
  struct FILE * gc_debug_file.59;
  struct MonoClass * D.18504;
  const char * D.18505;
  int D.18506;
  struct LOSObject * D.18511;
  struct SgenMajorCollector * D.18513;
  guint8 * (*<T2c81>) (char *) D.18514;
  _Bool D.18515;
  long int D.18516;
  long int D.18517;
  unsigned int D.18520;
  unsigned int D.18521;
  unsigned int D.18524;
  unsigned int D.18525;
  unsigned int D.18526;
  unsigned int D.18527;
  unsigned int D.18528;
  void * D.18529;
  int D.18532;
  int D.18535;
  struct SgenRemeberedSet * D.18538;
  gboolean (*<T2cbf>) (char *, guint8 *, char *) D.18539;
  int D.18540;
  int gc_debug_level.60;
  _Bool D.18544;
  long int D.18545;
  long int D.18546;
  int _objptr.61;
  int start.62;
  int D.18551;
  struct MonoVTable * D.18552;
  struct MonoClass * D.18553;
  const char * D.18554;
  const char * D.18555;
  int D.18558;
  int D.18561;
  struct SgenRemeberedSet * D.18564;
  gboolean (*<T2cbf>) (char *, guint8 *, char *) D.18565;
  int D.18566;
  unsigned int _index.63;
  unsigned int D.18572;
  int D.18573;
  void * D.18574;
  int D.18577;
  int D.18580;
  struct SgenRemeberedSet * D.18583;
  gboolean (*<T2cbf>) (char *, guint8 *, char *) D.18584;
  int D.18585;
  int _objptr.64;
  int D.18591;
  unsigned int _index.65;
  unsigned int D.18593;
  int D.18594;
  int D.18597;
  int D.18600;
  struct SgenRemeberedSet * D.18603;
  gboolean (*<T2cbf>) (char *, guint8 *, char *) D.18604;
  int D.18605;
  unsigned int D.18610;
  unsigned int D.18613;
  int D.18614;
  int desc.66;
  unsigned int D.18618;
  unsigned int el_size.67;
  unsigned int D.18620;
  void * D.18621;
  int D.18624;
  int D.18627;
  struct SgenRemeberedSet * D.18630;
  gboolean (*<T2cbf>) (char *, guint8 *, char *) D.18631;
  int D.18632;
  int p.68;
  int D.18638;
  int D.18642;
  unsigned int offset.69;
  unsigned int D.18644;
  unsigned int i.70;
  unsigned int D.18646;
  void * * D.18647;
  void * D.18648;
  int D.18651;
  int D.18654;
  struct SgenRemeberedSet * D.18657;
  gboolean (*<T2cbf>) (char *, guint8 *, char *) D.18658;
  char * D.18659;
  int D.18660;
  int D.18665;
  int D.18666;
  sizetype el_size.71;
  unsigned int D.18671;
  void * D.18674;
  int D.18677;
  int D.18680;
  struct SgenRemeberedSet * D.18683;
  gboolean (*<T2cbf>) (char *, guint8 *, char *) D.18684;
  int D.18685;
  int p.72;
  int D.18691;
  unsigned int D.18692;
  void * D.18695;
  int D.18698;
  int D.18701;
  struct SgenRemeberedSet * D.18704;
  gboolean (*<T2cbf>) (char *, guint8 *, char *) D.18705;
  int D.18706;
  int _objptr.73;
  int D.18712;
  unsigned int D.18713;
  unsigned int D.18714;
  struct MonoVTable * D.18717;
  struct MonoClass * D.18718;
  const char * D.18719;
  const char * D.18720;
  gsize * bitmap_data.74;
  unsigned int D.18722;
  void * D.18725;
  int D.18728;
  int D.18731;
  struct SgenRemeberedSet * D.18734;
  gboolean (*<T2cbf>) (char *, guint8 *, char *) D.18735;
  int D.18736;
  int _objptr.75;
  int D.18742;
  int bwords.76;
  unsigned int D.18744;
  gsize * mbitmap_data.77;
  unsigned int D.18746;
  unsigned int D.18747;
  struct MonoClass * D.18748;
  unsigned int el_size.78;
  unsigned int D.18750;
  const char * D.18753;
  const char * D.18754;
  gsize * bitmap_data.79;
  unsigned int D.18756;
  void * D.18759;
  int D.18762;
  int D.18765;
  struct SgenRemeberedSet * D.18768;
  gboolean (*<T2cbf>) (char *, guint8 *, char *) D.18769;
  int D.18770;
  int _objptr.80;
  int D.18776;
  unsigned int bwords.81;
  sizetype el_size.82;
  gboolean in_los;
  struct GCVTable * vt;
  guint8 * cards;

  in_los = (gboolean) dummy;
  D.18499 = MEM[(mword *)start];
  D.18500 = D.18499 & 4294967292;
  vt = (struct GCVTable *) D.18500;
  if (0 != 0) goto <D.18501>; else goto <D.18502>;
  <D.18501>:
  gc_debug_file.59 = gc_debug_file;
  D.18504 = vt->klass;
  D.18505 = D.18504->name;
  fprintf (gc_debug_file.59, "Scanning object %p, vtable: %p (%s)\n", start, vt, D.18505);
  gc_debug_file.59 = gc_debug_file;
  fflush (gc_debug_file.59);
  <D.18502>:
  D.18506 = is_major_or_los_object_marked (start);
  if (D.18506 == 0) goto <D.18507>; else goto <D.18508>;
  <D.18507>:
  return;
  <D.18508>:
  if (in_los != 0) goto <D.18509>; else goto <D.18510>;
  <D.18509>:
  D.18511 = sgen_los_header_for_object (start);
  cards = D.18511->cardtable_mod_union;
  goto <D.18512>;
  <D.18510>:
  D.18513 = sgen_get_major_collector ();
  D.18514 = D.18513->get_cardtable_mod_union_for_object;
  cards = D.18514 (start);
  <D.18512>:
  D.18515 = cards == 0B;
  D.18516 = (long int) D.18515;
  D.18517 = __builtin_expect (D.18516, 0);
  if (D.18517 != 0) goto <D.18518>; else goto <D.18519>;
  <D.18518>:
  monoeg_g_log (0B, 4, "we must have mod union for marked major objects");
  <D.17416>:
  goto <D.17416>;
  <D.18519>:
  {
    struct GCVTable * vt;
    mword desc;

    D.18499 = MEM[(mword *)start];
    D.18500 = D.18499 & 4294967292;
    vt = (struct GCVTable *) D.18500;
    desc = vt->desc;
    D.18520 = desc & 7;
    switch (D.18520) <default: <D.17504>, case 1: <D.17419>, case 2: <D.17426>, case 3: <D.17470>, case 4: <D.17434>, case 5: <D.17464>, case 6: <D.17483>, case 7: <D.17503>>
    <D.17419>:
    D.18521 = desc & 4294901760;
    if (D.18521 != 0) goto <D.18522>; else goto <D.18523>;
    <D.18522>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.18524 = desc >> 16;
      D.18525 = D.18524 & 255;
      D.18526 = D.18525 * 4;
      _objptr = _objptr + D.18526;
      D.18527 = desc >> 24;
      D.18528 = D.18527 * 4;
      _objptr_end = _objptr + D.18528;
      D.18529 = *_objptr;
      if (D.18529 != 0B) goto <D.18530>; else goto <D.18531>;
      <D.18530>:
      D.18529 = *_objptr;
      D.18532 = sgen_ptr_in_nursery (D.18529);
      if (D.18532 == 0) goto <D.18533>; else goto <D.18534>;
      <D.18533>:
      D.18529 = *_objptr;
      D.18535 = is_major_or_los_object_marked (D.18529);
      if (D.18535 == 0) goto <D.18536>; else goto <D.18537>;
      <D.18536>:
      D.18538 = sgen_get_remset ();
      D.18539 = D.18538->find_address_with_cards;
      D.18540 = D.18539 (start, cards, _objptr);
      if (D.18540 == 0) goto <D.18541>; else goto <D.18542>;
      <D.18541>:
      gc_debug_level.60 = gc_debug_level;
      D.18544 = gc_debug_level.60 >= 0;
      D.18545 = (long int) D.18544;
      D.18546 = __builtin_expect (D.18545, 0);
      if (D.18546 != 0) goto <D.18547>; else goto <D.18548>;
      <D.18547>:
      gc_debug_file.59 = gc_debug_file;
      D.18529 = *_objptr;
      _objptr.61 = (int) _objptr;
      start.62 = (int) start;
      D.18551 = _objptr.61 - start.62;
      D.18552 = MEM[(struct MonoObject *)start].vtable;
      D.18553 = D.18552->klass;
      D.18554 = D.18553->name_space;
      D.18552 = MEM[(struct MonoObject *)start].vtable;
      D.18553 = D.18552->klass;
      D.18555 = D.18553->name;
      fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18529, D.18551, start, D.18554, D.18555);
      gc_debug_file.59 = gc_debug_file;
      fflush (gc_debug_file.59);
      <D.18548>:
      <D.18542>:
      <D.18537>:
      <D.18534>:
      <D.18531>:
      _objptr = _objptr + 4;
      goto <D.17423>;
      <D.17422>:
      D.18529 = *_objptr;
      if (D.18529 != 0B) goto <D.18556>; else goto <D.18557>;
      <D.18556>:
      D.18529 = *_objptr;
      D.18558 = sgen_ptr_in_nursery (D.18529);
      if (D.18558 == 0) goto <D.18559>; else goto <D.18560>;
      <D.18559>:
      D.18529 = *_objptr;
      D.18561 = is_major_or_los_object_marked (D.18529);
      if (D.18561 == 0) goto <D.18562>; else goto <D.18563>;
      <D.18562>:
      D.18564 = sgen_get_remset ();
      D.18565 = D.18564->find_address_with_cards;
      D.18566 = D.18565 (start, cards, _objptr);
      if (D.18566 == 0) goto <D.18567>; else goto <D.18568>;
      <D.18567>:
      gc_debug_level.60 = gc_debug_level;
      D.18544 = gc_debug_level.60 >= 0;
      D.18545 = (long int) D.18544;
      D.18546 = __builtin_expect (D.18545, 0);
      if (D.18546 != 0) goto <D.18569>; else goto <D.18570>;
      <D.18569>:
      gc_debug_file.59 = gc_debug_file;
      D.18529 = *_objptr;
      _objptr.61 = (int) _objptr;
      start.62 = (int) start;
      D.18551 = _objptr.61 - start.62;
      D.18552 = MEM[(struct MonoObject *)start].vtable;
      D.18553 = D.18552->klass;
      D.18554 = D.18553->name_space;
      D.18552 = MEM[(struct MonoObject *)start].vtable;
      D.18553 = D.18552->klass;
      D.18555 = D.18553->name;
      fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18529, D.18551, start, D.18554, D.18555);
      gc_debug_file.59 = gc_debug_file;
      fflush (gc_debug_file.59);
      <D.18570>:
      <D.18568>:
      <D.18563>:
      <D.18560>:
      <D.18557>:
      _objptr = _objptr + 4;
      <D.17423>:
      if (_objptr < _objptr_end) goto <D.17422>; else goto <D.17424>;
      <D.17424>:
    }
    <D.18523>:
    goto <D.17425>;
    <D.17426>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.63 = (unsigned int) _index;
        D.18572 = _index.63 * 4;
        _objptr = _objptr + D.18572;
        D.18573 = _index + 1;
        _bmap = _bmap >> D.18573;
        D.18574 = *_objptr;
        if (D.18574 != 0B) goto <D.18575>; else goto <D.18576>;
        <D.18575>:
        D.18574 = *_objptr;
        D.18577 = sgen_ptr_in_nursery (D.18574);
        if (D.18577 == 0) goto <D.18578>; else goto <D.18579>;
        <D.18578>:
        D.18574 = *_objptr;
        D.18580 = is_major_or_los_object_marked (D.18574);
        if (D.18580 == 0) goto <D.18581>; else goto <D.18582>;
        <D.18581>:
        D.18583 = sgen_get_remset ();
        D.18584 = D.18583->find_address_with_cards;
        D.18585 = D.18584 (start, cards, _objptr);
        if (D.18585 == 0) goto <D.18586>; else goto <D.18587>;
        <D.18586>:
        gc_debug_level.60 = gc_debug_level;
        D.18544 = gc_debug_level.60 >= 0;
        D.18545 = (long int) D.18544;
        D.18546 = __builtin_expect (D.18545, 0);
        if (D.18546 != 0) goto <D.18588>; else goto <D.18589>;
        <D.18588>:
        gc_debug_file.59 = gc_debug_file;
        D.18574 = *_objptr;
        _objptr.64 = (int) _objptr;
        start.62 = (int) start;
        D.18591 = _objptr.64 - start.62;
        D.18552 = MEM[(struct MonoObject *)start].vtable;
        D.18553 = D.18552->klass;
        D.18554 = D.18553->name_space;
        D.18552 = MEM[(struct MonoObject *)start].vtable;
        D.18553 = D.18552->klass;
        D.18555 = D.18553->name;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18574, D.18591, start, D.18554, D.18555);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.18589>:
        <D.18587>:
        <D.18582>:
        <D.18579>:
        <D.18576>:
        _objptr = _objptr + 4;
      }
      goto <D.17432>;
      <D.17431>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.65 = (unsigned int) _index;
        D.18593 = _index.65 * 4;
        _objptr = _objptr + D.18593;
        D.18594 = _index + 1;
        _bmap = _bmap >> D.18594;
        D.18574 = *_objptr;
        if (D.18574 != 0B) goto <D.18595>; else goto <D.18596>;
        <D.18595>:
        D.18574 = *_objptr;
        D.18597 = sgen_ptr_in_nursery (D.18574);
        if (D.18597 == 0) goto <D.18598>; else goto <D.18599>;
        <D.18598>:
        D.18574 = *_objptr;
        D.18600 = is_major_or_los_object_marked (D.18574);
        if (D.18600 == 0) goto <D.18601>; else goto <D.18602>;
        <D.18601>:
        D.18603 = sgen_get_remset ();
        D.18604 = D.18603->find_address_with_cards;
        D.18605 = D.18604 (start, cards, _objptr);
        if (D.18605 == 0) goto <D.18606>; else goto <D.18607>;
        <D.18606>:
        gc_debug_level.60 = gc_debug_level;
        D.18544 = gc_debug_level.60 >= 0;
        D.18545 = (long int) D.18544;
        D.18546 = __builtin_expect (D.18545, 0);
        if (D.18546 != 0) goto <D.18608>; else goto <D.18609>;
        <D.18608>:
        gc_debug_file.59 = gc_debug_file;
        D.18574 = *_objptr;
        _objptr.64 = (int) _objptr;
        start.62 = (int) start;
        D.18591 = _objptr.64 - start.62;
        D.18552 = MEM[(struct MonoObject *)start].vtable;
        D.18553 = D.18552->klass;
        D.18554 = D.18553->name_space;
        D.18552 = MEM[(struct MonoObject *)start].vtable;
        D.18553 = D.18552->klass;
        D.18555 = D.18553->name;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18574, D.18591, start, D.18554, D.18555);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.18609>:
        <D.18607>:
        <D.18602>:
        <D.18599>:
        <D.18596>:
        _objptr = _objptr + 4;
      }
      <D.17432>:
      if (_bmap != 0) goto <D.17431>; else goto <D.17433>;
      <D.17433>:
    }
    goto <D.17425>;
    <D.17434>:
    D.18610 = desc & 4294950912;
    if (D.18610 != 0) goto <D.18611>; else goto <D.18612>;
    <D.18611>:
    {
      int el_size;
      int etype;

      D.18613 = desc >> 3;
      D.18614 = (int) D.18613;
      el_size = D.18614 & 1023;
      desc.66 = (int) desc;
      etype = desc.66 & 49152;
      if (etype == 16384) goto <D.18616>; else goto <D.18617>;
      <D.18616>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.18618 = MEM[(struct MonoArray *)start].max_length;
        el_size.67 = (unsigned int) el_size;
        D.18620 = D.18618 * el_size.67;
        end_refs = p + D.18620;
        goto <D.17440>;
        <D.17439>:
        D.18621 = *p;
        if (D.18621 != 0B) goto <D.18622>; else goto <D.18623>;
        <D.18622>:
        D.18621 = *p;
        D.18624 = sgen_ptr_in_nursery (D.18621);
        if (D.18624 == 0) goto <D.18625>; else goto <D.18626>;
        <D.18625>:
        D.18621 = *p;
        D.18627 = is_major_or_los_object_marked (D.18621);
        if (D.18627 == 0) goto <D.18628>; else goto <D.18629>;
        <D.18628>:
        D.18630 = sgen_get_remset ();
        D.18631 = D.18630->find_address_with_cards;
        D.18632 = D.18631 (start, cards, p);
        if (D.18632 == 0) goto <D.18633>; else goto <D.18634>;
        <D.18633>:
        gc_debug_level.60 = gc_debug_level;
        D.18544 = gc_debug_level.60 >= 0;
        D.18545 = (long int) D.18544;
        D.18546 = __builtin_expect (D.18545, 0);
        if (D.18546 != 0) goto <D.18635>; else goto <D.18636>;
        <D.18635>:
        gc_debug_file.59 = gc_debug_file;
        D.18621 = *p;
        p.68 = (int) p;
        start.62 = (int) start;
        D.18638 = p.68 - start.62;
        D.18552 = MEM[(struct MonoObject *)start].vtable;
        D.18553 = D.18552->klass;
        D.18554 = D.18553->name_space;
        D.18552 = MEM[(struct MonoObject *)start].vtable;
        D.18553 = D.18552->klass;
        D.18555 = D.18553->name;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18621, D.18638, start, D.18554, D.18555);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.18636>:
        <D.18634>:
        <D.18629>:
        <D.18626>:
        <D.18623>:
        p = p + 4;
        <D.17440>:
        if (p < end_refs) goto <D.17439>; else goto <D.17441>;
        <D.17441>:
      }
      goto <D.18639>;
      <D.18617>:
      if (etype == 32768) goto <D.18640>; else goto <D.18641>;
      <D.18640>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.18524 = desc >> 16;
        D.18642 = (int) D.18524;
        offset = D.18642 & 255;
        D.18527 = desc >> 24;
        num_refs = (int) D.18527;
        e_start = start + 16;
        D.18618 = MEM[(struct MonoArray *)start].max_length;
        el_size.67 = (unsigned int) el_size;
        D.18620 = D.18618 * el_size.67;
        e_end = e_start + D.18620;
        goto <D.17452>;
        <D.17451>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.69 = (unsigned int) offset;
          D.18644 = offset.69 * 4;
          p = p + D.18644;
          i = 0;
          goto <D.17449>;
          <D.17448>:
          i.70 = (unsigned int) i;
          D.18646 = i.70 * 4;
          D.18647 = p + D.18646;
          D.18648 = *D.18647;
          if (D.18648 != 0B) goto <D.18649>; else goto <D.18650>;
          <D.18649>:
          i.70 = (unsigned int) i;
          D.18646 = i.70 * 4;
          D.18647 = p + D.18646;
          D.18648 = *D.18647;
          D.18651 = sgen_ptr_in_nursery (D.18648);
          if (D.18651 == 0) goto <D.18652>; else goto <D.18653>;
          <D.18652>:
          i.70 = (unsigned int) i;
          D.18646 = i.70 * 4;
          D.18647 = p + D.18646;
          D.18648 = *D.18647;
          D.18654 = is_major_or_los_object_marked (D.18648);
          if (D.18654 == 0) goto <D.18655>; else goto <D.18656>;
          <D.18655>:
          D.18657 = sgen_get_remset ();
          D.18658 = D.18657->find_address_with_cards;
          i.70 = (unsigned int) i;
          D.18646 = i.70 * 4;
          D.18659 = p + D.18646;
          D.18660 = D.18658 (start, cards, D.18659);
          if (D.18660 == 0) goto <D.18661>; else goto <D.18662>;
          <D.18661>:
          gc_debug_level.60 = gc_debug_level;
          D.18544 = gc_debug_level.60 >= 0;
          D.18545 = (long int) D.18544;
          D.18546 = __builtin_expect (D.18545, 0);
          if (D.18546 != 0) goto <D.18663>; else goto <D.18664>;
          <D.18663>:
          gc_debug_file.59 = gc_debug_file;
          i.70 = (unsigned int) i;
          D.18646 = i.70 * 4;
          D.18647 = p + D.18646;
          D.18648 = *D.18647;
          i.70 = (unsigned int) i;
          D.18646 = i.70 * 4;
          D.18659 = p + D.18646;
          D.18665 = (int) D.18659;
          start.62 = (int) start;
          D.18666 = D.18665 - start.62;
          D.18552 = MEM[(struct MonoObject *)start].vtable;
          D.18553 = D.18552->klass;
          D.18554 = D.18553->name_space;
          D.18552 = MEM[(struct MonoObject *)start].vtable;
          D.18553 = D.18552->klass;
          D.18555 = D.18553->name;
          fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18648, D.18666, start, D.18554, D.18555);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.18664>:
          <D.18662>:
          <D.18656>:
          <D.18653>:
          <D.18650>:
          i = i + 1;
          <D.17449>:
          if (i < num_refs) goto <D.17448>; else goto <D.17450>;
          <D.17450>:
          el_size.71 = (sizetype) el_size;
          e_start = e_start + el_size.71;
        }
        <D.17452>:
        if (e_start < e_end) goto <D.17451>; else goto <D.17453>;
        <D.17453>:
      }
      goto <D.18668>;
      <D.18641>:
      if (etype == 49152) goto <D.18669>; else goto <D.18670>;
      <D.18669>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.18618 = MEM[(struct MonoArray *)start].max_length;
        el_size.67 = (unsigned int) el_size;
        D.18620 = D.18618 * el_size.67;
        e_end = e_start + D.18620;
        goto <D.17462>;
        <D.17461>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17459>;
          <D.17458>:
          D.18671 = _bmap & 1;
          if (D.18671 != 0) goto <D.18672>; else goto <D.18673>;
          <D.18672>:
          D.18674 = *p;
          if (D.18674 != 0B) goto <D.18675>; else goto <D.18676>;
          <D.18675>:
          D.18674 = *p;
          D.18677 = sgen_ptr_in_nursery (D.18674);
          if (D.18677 == 0) goto <D.18678>; else goto <D.18679>;
          <D.18678>:
          D.18674 = *p;
          D.18680 = is_major_or_los_object_marked (D.18674);
          if (D.18680 == 0) goto <D.18681>; else goto <D.18682>;
          <D.18681>:
          D.18683 = sgen_get_remset ();
          D.18684 = D.18683->find_address_with_cards;
          D.18685 = D.18684 (start, cards, p);
          if (D.18685 == 0) goto <D.18686>; else goto <D.18687>;
          <D.18686>:
          gc_debug_level.60 = gc_debug_level;
          D.18544 = gc_debug_level.60 >= 0;
          D.18545 = (long int) D.18544;
          D.18546 = __builtin_expect (D.18545, 0);
          if (D.18546 != 0) goto <D.18688>; else goto <D.18689>;
          <D.18688>:
          gc_debug_file.59 = gc_debug_file;
          D.18674 = *p;
          p.72 = (int) p;
          start.62 = (int) start;
          D.18691 = p.72 - start.62;
          D.18552 = MEM[(struct MonoObject *)start].vtable;
          D.18553 = D.18552->klass;
          D.18554 = D.18553->name_space;
          D.18552 = MEM[(struct MonoObject *)start].vtable;
          D.18553 = D.18552->klass;
          D.18555 = D.18553->name;
          fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18674, D.18691, start, D.18554, D.18555);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.18689>:
          <D.18687>:
          <D.18682>:
          <D.18679>:
          <D.18676>:
          <D.18673>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17459>:
          if (_bmap != 0) goto <D.17458>; else goto <D.17460>;
          <D.17460>:
          el_size.71 = (sizetype) el_size;
          e_start = e_start + el_size.71;
        }
        <D.17462>:
        if (e_start < e_end) goto <D.17461>; else goto <D.17463>;
        <D.17463>:
      }
      <D.18670>:
      <D.18668>:
      <D.18639>:
    }
    <D.18612>:
    goto <D.17425>;
    <D.17464>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17468>;
      <D.17467>:
      D.18692 = _bmap & 1;
      if (D.18692 != 0) goto <D.18693>; else goto <D.18694>;
      <D.18693>:
      D.18695 = *_objptr;
      if (D.18695 != 0B) goto <D.18696>; else goto <D.18697>;
      <D.18696>:
      D.18695 = *_objptr;
      D.18698 = sgen_ptr_in_nursery (D.18695);
      if (D.18698 == 0) goto <D.18699>; else goto <D.18700>;
      <D.18699>:
      D.18695 = *_objptr;
      D.18701 = is_major_or_los_object_marked (D.18695);
      if (D.18701 == 0) goto <D.18702>; else goto <D.18703>;
      <D.18702>:
      D.18704 = sgen_get_remset ();
      D.18705 = D.18704->find_address_with_cards;
      D.18706 = D.18705 (start, cards, _objptr);
      if (D.18706 == 0) goto <D.18707>; else goto <D.18708>;
      <D.18707>:
      gc_debug_level.60 = gc_debug_level;
      D.18544 = gc_debug_level.60 >= 0;
      D.18545 = (long int) D.18544;
      D.18546 = __builtin_expect (D.18545, 0);
      if (D.18546 != 0) goto <D.18709>; else goto <D.18710>;
      <D.18709>:
      gc_debug_file.59 = gc_debug_file;
      D.18695 = *_objptr;
      _objptr.73 = (int) _objptr;
      start.62 = (int) start;
      D.18712 = _objptr.73 - start.62;
      D.18552 = MEM[(struct MonoObject *)start].vtable;
      D.18553 = D.18552->klass;
      D.18554 = D.18553->name_space;
      D.18552 = MEM[(struct MonoObject *)start].vtable;
      D.18553 = D.18552->klass;
      D.18555 = D.18553->name;
      fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18695, D.18712, start, D.18554, D.18555);
      gc_debug_file.59 = gc_debug_file;
      fflush (gc_debug_file.59);
      <D.18710>:
      <D.18708>:
      <D.18703>:
      <D.18700>:
      <D.18697>:
      <D.18694>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17468>:
      if (_bmap != 0) goto <D.17467>; else goto <D.17469>;
      <D.17469>:
    }
    goto <D.17425>;
    <D.17470>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.18713 = *bitmap_data;
      D.18714 = D.18713 + 4294967295;
      bwords = (int) D.18714;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.18715>; else goto <D.18716>;
      <D.18715>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.18717 = myobj->vtable;
        D.18718 = D.18717->klass;
        D.18719 = D.18718->name_space;
        D.18717 = myobj->vtable;
        D.18718 = D.18717->klass;
        D.18720 = D.18718->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18719, D.18720);
      }
      <D.18716>:
      goto <D.17481>;
      <D.17480>:
      {
        gsize _bmap;

        bitmap_data.74 = bitmap_data;
        bitmap_data = bitmap_data.74 + 4;
        _bmap = *bitmap_data.74;
        _objptr = start_run;
        goto <D.17478>;
        <D.17477>:
        D.18722 = _bmap & 1;
        if (D.18722 != 0) goto <D.18723>; else goto <D.18724>;
        <D.18723>:
        D.18725 = *_objptr;
        if (D.18725 != 0B) goto <D.18726>; else goto <D.18727>;
        <D.18726>:
        D.18725 = *_objptr;
        D.18728 = sgen_ptr_in_nursery (D.18725);
        if (D.18728 == 0) goto <D.18729>; else goto <D.18730>;
        <D.18729>:
        D.18725 = *_objptr;
        D.18731 = is_major_or_los_object_marked (D.18725);
        if (D.18731 == 0) goto <D.18732>; else goto <D.18733>;
        <D.18732>:
        D.18734 = sgen_get_remset ();
        D.18735 = D.18734->find_address_with_cards;
        D.18736 = D.18735 (start, cards, _objptr);
        if (D.18736 == 0) goto <D.18737>; else goto <D.18738>;
        <D.18737>:
        gc_debug_level.60 = gc_debug_level;
        D.18544 = gc_debug_level.60 >= 0;
        D.18545 = (long int) D.18544;
        D.18546 = __builtin_expect (D.18545, 0);
        if (D.18546 != 0) goto <D.18739>; else goto <D.18740>;
        <D.18739>:
        gc_debug_file.59 = gc_debug_file;
        D.18725 = *_objptr;
        _objptr.75 = (int) _objptr;
        start.62 = (int) start;
        D.18742 = _objptr.75 - start.62;
        D.18552 = MEM[(struct MonoObject *)start].vtable;
        D.18553 = D.18552->klass;
        D.18554 = D.18553->name_space;
        D.18552 = MEM[(struct MonoObject *)start].vtable;
        D.18553 = D.18552->klass;
        D.18555 = D.18553->name;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18725, D.18742, start, D.18554, D.18555);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.18740>:
        <D.18738>:
        <D.18733>:
        <D.18730>:
        <D.18727>:
        <D.18724>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17478>:
        if (_bmap != 0) goto <D.17477>; else goto <D.17479>;
        <D.17479>:
        start_run = start_run + 128;
      }
      <D.17481>:
      bwords.76 = bwords;
      bwords = bwords.76 + -1;
      if (bwords.76 > 0) goto <D.17480>; else goto <D.17482>;
      <D.17482>:
    }
    goto <D.17425>;
    <D.17483>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.18744 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.18744);
      mbitmap_data.77 = mbitmap_data;
      mbitmap_data = mbitmap_data.77 + 4;
      D.18746 = *mbitmap_data.77;
      D.18747 = D.18746 + 4294967295;
      mbwords = (int) D.18747;
      D.18748 = vt->klass;
      el_size = mono_array_element_size (D.18748);
      e_start = start + 16;
      D.18618 = MEM[(struct MonoArray *)start].max_length;
      el_size.78 = (unsigned int) el_size;
      D.18750 = D.18618 * el_size.78;
      e_end = e_start + D.18750;
      if (0 != 0) goto <D.18751>; else goto <D.18752>;
      <D.18751>:
      D.18744 = vt->desc;
      D.18748 = vt->klass;
      D.18753 = D.18748->name_space;
      D.18748 = vt->klass;
      D.18754 = D.18748->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.18744, D.18753, D.18754);
      <D.18752>:
      goto <D.17501>;
      <D.17500>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.17498>;
        <D.17497>:
        {
          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.17495>;
          <D.17494>:
          D.18756 = _bmap & 1;
          if (D.18756 != 0) goto <D.18757>; else goto <D.18758>;
          <D.18757>:
          D.18759 = *_objptr;
          if (D.18759 != 0B) goto <D.18760>; else goto <D.18761>;
          <D.18760>:
          D.18759 = *_objptr;
          D.18762 = sgen_ptr_in_nursery (D.18759);
          if (D.18762 == 0) goto <D.18763>; else goto <D.18764>;
          <D.18763>:
          D.18759 = *_objptr;
          D.18765 = is_major_or_los_object_marked (D.18759);
          if (D.18765 == 0) goto <D.18766>; else goto <D.18767>;
          <D.18766>:
          D.18768 = sgen_get_remset ();
          D.18769 = D.18768->find_address_with_cards;
          D.18770 = D.18769 (start, cards, _objptr);
          if (D.18770 == 0) goto <D.18771>; else goto <D.18772>;
          <D.18771>:
          gc_debug_level.60 = gc_debug_level;
          D.18544 = gc_debug_level.60 >= 0;
          D.18545 = (long int) D.18544;
          D.18546 = __builtin_expect (D.18545, 0);
          if (D.18546 != 0) goto <D.18773>; else goto <D.18774>;
          <D.18773>:
          gc_debug_file.59 = gc_debug_file;
          D.18759 = *_objptr;
          _objptr.80 = (int) _objptr;
          start.62 = (int) start;
          D.18776 = _objptr.80 - start.62;
          D.18552 = MEM[(struct MonoObject *)start].vtable;
          D.18553 = D.18552->klass;
          D.18554 = D.18553->name_space;
          D.18552 = MEM[(struct MonoObject *)start].vtable;
          D.18553 = D.18552->klass;
          D.18555 = D.18553->name;
          fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18759, D.18776, start, D.18554, D.18555);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.18774>:
          <D.18772>:
          <D.18767>:
          <D.18764>:
          <D.18761>:
          <D.18758>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17495>:
          if (_bmap != 0) goto <D.17494>; else goto <D.17496>;
          <D.17496>:
          _objptr = start_run + 128;
        }
        <D.17498>:
        bwords.81 = bwords;
        bwords = bwords.81 + 4294967295;
        if (bwords.81 != 0) goto <D.17497>; else goto <D.17499>;
        <D.17499>:
        el_size.82 = (sizetype) el_size;
        e_start = e_start + el_size.82;
      }
      <D.17501>:
      if (e_start < e_end) goto <D.17500>; else goto <D.17502>;
      <D.17502>:
    }
    goto <D.17425>;
    <D.17503>:
    goto <D.17425>;
    <D.17504>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17425>:
  }
}


is_major_or_los_object_marked (char * obj)
{
  unsigned int D.18781;
  gboolean D.18784;
  struct SgenMajorCollector * D.18785;
  gboolean (*<T2be4>) (char *) D.18786;

  D.18781 = sgen_safe_object_get_size (obj);
  if (D.18781 > 8000) goto <D.18782>; else goto <D.18783>;
  <D.18782>:
  D.18784 = sgen_los_object_is_pinned (obj);
  return D.18784;
  <D.18783>:
  D.18785 = sgen_get_major_collector ();
  D.18786 = D.18785->is_object_live;
  D.18784 = D.18786 (obj);
  return D.18784;
}


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

  D.18788 = major_collector.iterate_objects;
  D.18788 (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.18789;
  unsigned int D.18790;
  unsigned int D.18791;
  unsigned int D.18792;
  unsigned int D.18795;
  unsigned int D.18796;
  unsigned int D.18797;
  unsigned int D.18798;
  unsigned int D.18799;
  void * D.18800;
  unsigned int D.18803;
  unsigned int D.18804;
  int _objptr.83;
  int start.84;
  int D.18809;
  unsigned int D.18810;
  unsigned int D.18815;
  unsigned int _index.85;
  unsigned int D.18817;
  int D.18818;
  void * D.18819;
  unsigned int D.18822;
  unsigned int D.18823;
  int _objptr.86;
  int D.18827;
  unsigned int D.18828;
  unsigned int _index.87;
  unsigned int D.18830;
  int D.18831;
  unsigned int D.18836;
  unsigned int D.18837;
  unsigned int D.18840;
  int D.18841;
  int desc.88;
  unsigned int D.18845;
  unsigned int el_size.89;
  unsigned int D.18847;
  void * D.18848;
  unsigned int D.18851;
  unsigned int D.18852;
  int p.90;
  int D.18856;
  unsigned int D.18857;
  int D.18861;
  unsigned int offset.91;
  unsigned int D.18863;
  unsigned int i.92;
  unsigned int D.18865;
  void * * D.18866;
  void * D.18867;
  unsigned int D.18870;
  unsigned int D.18871;
  sizetype i.93;
  char * D.18875;
  int D.18876;
  int D.18877;
  unsigned int D.18878;
  sizetype el_size.94;
  unsigned int D.18883;
  void * D.18886;
  unsigned int D.18889;
  unsigned int D.18890;
  int p.95;
  int D.18894;
  unsigned int D.18895;
  unsigned int D.18896;
  void * D.18899;
  unsigned int D.18902;
  unsigned int D.18903;
  int _objptr.96;
  int D.18907;
  unsigned int D.18908;
  unsigned int D.18909;
  unsigned int D.18910;
  struct MonoVTable * D.18913;
  struct MonoClass * D.18914;
  const char * D.18915;
  const char * D.18916;
  gsize * bitmap_data.97;
  unsigned int D.18918;
  void * D.18921;
  unsigned int D.18924;
  unsigned int D.18925;
  int _objptr.98;
  int D.18929;
  unsigned int D.18930;
  int bwords.99;
  unsigned int D.18932;
  gsize * mbitmap_data.100;
  unsigned int D.18934;
  unsigned int D.18935;
  struct MonoClass * D.18936;
  unsigned int el_size.101;
  unsigned int D.18938;
  const char * D.18941;
  const char * D.18942;
  gsize * bitmap_data.102;
  unsigned int D.18944;
  void * D.18947;
  unsigned int D.18950;
  unsigned int D.18951;
  int _objptr.103;
  int D.18955;
  unsigned int D.18956;
  unsigned int bwords.104;
  sizetype el_size.105;

  {
    struct GCVTable * vt;
    mword desc;

    D.18789 = MEM[(mword *)start];
    D.18790 = D.18789 & 4294967292;
    vt = (struct GCVTable *) D.18790;
    desc = vt->desc;
    D.18791 = desc & 7;
    switch (D.18791) <default: <D.17610>, case 1: <D.17515>, case 2: <D.17524>, case 3: <D.17574>, case 4: <D.17534>, case 5: <D.17567>, case 6: <D.17588>, case 7: <D.17609>>
    <D.17515>:
    D.18792 = desc & 4294901760;
    if (D.18792 != 0) goto <D.18793>; else goto <D.18794>;
    <D.18793>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.18795 = desc >> 16;
      D.18796 = D.18795 & 255;
      D.18797 = D.18796 * 4;
      _objptr = _objptr + D.18797;
      D.18798 = desc >> 24;
      D.18799 = D.18798 * 4;
      _objptr_end = _objptr + D.18799;
      D.18800 = *_objptr;
      if (D.18800 != 0B) goto <D.18801>; else goto <D.18802>;
      <D.18801>:
      D.18800 = *_objptr;
      D.18803 = MEM[(mword *)D.18800];
      D.18804 = D.18803 & 4294967292;
      if (D.18804 == 0) goto <D.18805>; else goto <D.18806>;
      <D.18805>:
      _objptr.83 = (int) _objptr;
      start.84 = (int) start;
      D.18809 = _objptr.83 - start.84;
      D.18810 = sgen_safe_object_get_size (start);
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18809, D.18810);
      <D.17518>:
      goto <D.17518>;
      <D.18806>:
      <D.18802>:
      _objptr = _objptr + 4;
      goto <D.17521>;
      <D.17520>:
      D.18800 = *_objptr;
      if (D.18800 != 0B) goto <D.18811>; else goto <D.18812>;
      <D.18811>:
      D.18800 = *_objptr;
      D.18803 = MEM[(mword *)D.18800];
      D.18804 = D.18803 & 4294967292;
      if (D.18804 == 0) goto <D.18813>; else goto <D.18814>;
      <D.18813>:
      _objptr.83 = (int) _objptr;
      start.84 = (int) start;
      D.18809 = _objptr.83 - start.84;
      D.18815 = sgen_safe_object_get_size (start);
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18809, D.18815);
      <D.17519>:
      goto <D.17519>;
      <D.18814>:
      <D.18812>:
      _objptr = _objptr + 4;
      <D.17521>:
      if (_objptr < _objptr_end) goto <D.17520>; else goto <D.17522>;
      <D.17522>:
    }
    <D.18794>:
    goto <D.17523>;
    <D.17524>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.85 = (unsigned int) _index;
        D.18817 = _index.85 * 4;
        _objptr = _objptr + D.18817;
        D.18818 = _index + 1;
        _bmap = _bmap >> D.18818;
        D.18819 = *_objptr;
        if (D.18819 != 0B) goto <D.18820>; else goto <D.18821>;
        <D.18820>:
        D.18819 = *_objptr;
        D.18822 = MEM[(mword *)D.18819];
        D.18823 = D.18822 & 4294967292;
        if (D.18823 == 0) goto <D.18824>; else goto <D.18825>;
        <D.18824>:
        _objptr.86 = (int) _objptr;
        start.84 = (int) start;
        D.18827 = _objptr.86 - start.84;
        D.18828 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18827, D.18828);
        <D.17528>:
        goto <D.17528>;
        <D.18825>:
        <D.18821>:
        _objptr = _objptr + 4;
      }
      goto <D.17532>;
      <D.17531>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.87 = (unsigned int) _index;
        D.18830 = _index.87 * 4;
        _objptr = _objptr + D.18830;
        D.18831 = _index + 1;
        _bmap = _bmap >> D.18831;
        D.18819 = *_objptr;
        if (D.18819 != 0B) goto <D.18832>; else goto <D.18833>;
        <D.18832>:
        D.18819 = *_objptr;
        D.18822 = MEM[(mword *)D.18819];
        D.18823 = D.18822 & 4294967292;
        if (D.18823 == 0) goto <D.18834>; else goto <D.18835>;
        <D.18834>:
        _objptr.86 = (int) _objptr;
        start.84 = (int) start;
        D.18827 = _objptr.86 - start.84;
        D.18836 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18827, D.18836);
        <D.17530>:
        goto <D.17530>;
        <D.18835>:
        <D.18833>:
        _objptr = _objptr + 4;
      }
      <D.17532>:
      if (_bmap != 0) goto <D.17531>; else goto <D.17533>;
      <D.17533>:
    }
    goto <D.17523>;
    <D.17534>:
    D.18837 = desc & 4294950912;
    if (D.18837 != 0) goto <D.18838>; else goto <D.18839>;
    <D.18838>:
    {
      int el_size;
      int etype;

      D.18840 = desc >> 3;
      D.18841 = (int) D.18840;
      el_size = D.18841 & 1023;
      desc.88 = (int) desc;
      etype = desc.88 & 49152;
      if (etype == 16384) goto <D.18843>; else goto <D.18844>;
      <D.18843>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.18845 = MEM[(struct MonoArray *)start].max_length;
        el_size.89 = (unsigned int) el_size;
        D.18847 = D.18845 * el_size.89;
        end_refs = p + D.18847;
        goto <D.17541>;
        <D.17540>:
        D.18848 = *p;
        if (D.18848 != 0B) goto <D.18849>; else goto <D.18850>;
        <D.18849>:
        D.18848 = *p;
        D.18851 = MEM[(mword *)D.18848];
        D.18852 = D.18851 & 4294967292;
        if (D.18852 == 0) goto <D.18853>; else goto <D.18854>;
        <D.18853>:
        p.90 = (int) p;
        start.84 = (int) start;
        D.18856 = p.90 - start.84;
        D.18857 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18856, D.18857);
        <D.17539>:
        goto <D.17539>;
        <D.18854>:
        <D.18850>:
        p = p + 4;
        <D.17541>:
        if (p < end_refs) goto <D.17540>; else goto <D.17542>;
        <D.17542>:
      }
      goto <D.18858>;
      <D.18844>:
      if (etype == 32768) goto <D.18859>; else goto <D.18860>;
      <D.18859>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.18795 = desc >> 16;
        D.18861 = (int) D.18795;
        offset = D.18861 & 255;
        D.18798 = desc >> 24;
        num_refs = (int) D.18798;
        e_start = start + 16;
        D.18845 = MEM[(struct MonoArray *)start].max_length;
        el_size.89 = (unsigned int) el_size;
        D.18847 = D.18845 * el_size.89;
        e_end = e_start + D.18847;
        goto <D.17554>;
        <D.17553>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.91 = (unsigned int) offset;
          D.18863 = offset.91 * 4;
          p = p + D.18863;
          i = 0;
          goto <D.17551>;
          <D.17550>:
          i.92 = (unsigned int) i;
          D.18865 = i.92 * 4;
          D.18866 = p + D.18865;
          D.18867 = *D.18866;
          if (D.18867 != 0B) goto <D.18868>; else goto <D.18869>;
          <D.18868>:
          i.92 = (unsigned int) i;
          D.18865 = i.92 * 4;
          D.18866 = p + D.18865;
          D.18867 = *D.18866;
          D.18870 = MEM[(mword *)D.18867];
          D.18871 = D.18870 & 4294967292;
          if (D.18871 == 0) goto <D.18872>; else goto <D.18873>;
          <D.18872>:
          i.93 = (sizetype) i;
          D.18875 = p + i.93;
          D.18876 = (int) D.18875;
          start.84 = (int) start;
          D.18877 = D.18876 - start.84;
          D.18878 = sgen_safe_object_get_size (start);
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18877, D.18878);
          <D.17549>:
          goto <D.17549>;
          <D.18873>:
          <D.18869>:
          i = i + 1;
          <D.17551>:
          if (i < num_refs) goto <D.17550>; else goto <D.17552>;
          <D.17552>:
          el_size.94 = (sizetype) el_size;
          e_start = e_start + el_size.94;
        }
        <D.17554>:
        if (e_start < e_end) goto <D.17553>; else goto <D.17555>;
        <D.17555>:
      }
      goto <D.18880>;
      <D.18860>:
      if (etype == 49152) goto <D.18881>; else goto <D.18882>;
      <D.18881>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.18845 = MEM[(struct MonoArray *)start].max_length;
        el_size.89 = (unsigned int) el_size;
        D.18847 = D.18845 * el_size.89;
        e_end = e_start + D.18847;
        goto <D.17565>;
        <D.17564>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17562>;
          <D.17561>:
          D.18883 = _bmap & 1;
          if (D.18883 != 0) goto <D.18884>; else goto <D.18885>;
          <D.18884>:
          D.18886 = *p;
          if (D.18886 != 0B) goto <D.18887>; else goto <D.18888>;
          <D.18887>:
          D.18886 = *p;
          D.18889 = MEM[(mword *)D.18886];
          D.18890 = D.18889 & 4294967292;
          if (D.18890 == 0) goto <D.18891>; else goto <D.18892>;
          <D.18891>:
          p.95 = (int) p;
          start.84 = (int) start;
          D.18894 = p.95 - start.84;
          D.18895 = sgen_safe_object_get_size (start);
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18894, D.18895);
          <D.17560>:
          goto <D.17560>;
          <D.18892>:
          <D.18888>:
          <D.18885>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17562>:
          if (_bmap != 0) goto <D.17561>; else goto <D.17563>;
          <D.17563>:
          el_size.94 = (sizetype) el_size;
          e_start = e_start + el_size.94;
        }
        <D.17565>:
        if (e_start < e_end) goto <D.17564>; else goto <D.17566>;
        <D.17566>:
      }
      <D.18882>:
      <D.18880>:
      <D.18858>:
    }
    <D.18839>:
    goto <D.17523>;
    <D.17567>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17572>;
      <D.17571>:
      D.18896 = _bmap & 1;
      if (D.18896 != 0) goto <D.18897>; else goto <D.18898>;
      <D.18897>:
      D.18899 = *_objptr;
      if (D.18899 != 0B) goto <D.18900>; else goto <D.18901>;
      <D.18900>:
      D.18899 = *_objptr;
      D.18902 = MEM[(mword *)D.18899];
      D.18903 = D.18902 & 4294967292;
      if (D.18903 == 0) goto <D.18904>; else goto <D.18905>;
      <D.18904>:
      _objptr.96 = (int) _objptr;
      start.84 = (int) start;
      D.18907 = _objptr.96 - start.84;
      D.18908 = sgen_safe_object_get_size (start);
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18907, D.18908);
      <D.17570>:
      goto <D.17570>;
      <D.18905>:
      <D.18901>:
      <D.18898>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17572>:
      if (_bmap != 0) goto <D.17571>; else goto <D.17573>;
      <D.17573>:
    }
    goto <D.17523>;
    <D.17574>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.18909 = *bitmap_data;
      D.18910 = D.18909 + 4294967295;
      bwords = (int) D.18910;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.18911>; else goto <D.18912>;
      <D.18911>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.18913 = myobj->vtable;
        D.18914 = D.18913->klass;
        D.18915 = D.18914->name_space;
        D.18913 = myobj->vtable;
        D.18914 = D.18913->klass;
        D.18916 = D.18914->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18915, D.18916);
      }
      <D.18912>:
      goto <D.17586>;
      <D.17585>:
      {
        gsize _bmap;

        bitmap_data.97 = bitmap_data;
        bitmap_data = bitmap_data.97 + 4;
        _bmap = *bitmap_data.97;
        _objptr = start_run;
        goto <D.17583>;
        <D.17582>:
        D.18918 = _bmap & 1;
        if (D.18918 != 0) goto <D.18919>; else goto <D.18920>;
        <D.18919>:
        D.18921 = *_objptr;
        if (D.18921 != 0B) goto <D.18922>; else goto <D.18923>;
        <D.18922>:
        D.18921 = *_objptr;
        D.18924 = MEM[(mword *)D.18921];
        D.18925 = D.18924 & 4294967292;
        if (D.18925 == 0) goto <D.18926>; else goto <D.18927>;
        <D.18926>:
        _objptr.98 = (int) _objptr;
        start.84 = (int) start;
        D.18929 = _objptr.98 - start.84;
        D.18930 = sgen_safe_object_get_size (start);
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18929, D.18930);
        <D.17581>:
        goto <D.17581>;
        <D.18927>:
        <D.18923>:
        <D.18920>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17583>:
        if (_bmap != 0) goto <D.17582>; else goto <D.17584>;
        <D.17584>:
        start_run = start_run + 128;
      }
      <D.17586>:
      bwords.99 = bwords;
      bwords = bwords.99 + -1;
      if (bwords.99 > 0) goto <D.17585>; else goto <D.17587>;
      <D.17587>:
    }
    goto <D.17523>;
    <D.17588>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.18932 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.18932);
      mbitmap_data.100 = mbitmap_data;
      mbitmap_data = mbitmap_data.100 + 4;
      D.18934 = *mbitmap_data.100;
      D.18935 = D.18934 + 4294967295;
      mbwords = (int) D.18935;
      D.18936 = vt->klass;
      el_size = mono_array_element_size (D.18936);
      e_start = start + 16;
      D.18845 = MEM[(struct MonoArray *)start].max_length;
      el_size.101 = (unsigned int) el_size;
      D.18938 = D.18845 * el_size.101;
      e_end = e_start + D.18938;
      if (0 != 0) goto <D.18939>; else goto <D.18940>;
      <D.18939>:
      D.18932 = vt->desc;
      D.18936 = vt->klass;
      D.18941 = D.18936->name_space;
      D.18936 = vt->klass;
      D.18942 = D.18936->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.18932, D.18941, D.18942);
      <D.18940>:
      goto <D.17607>;
      <D.17606>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.17604>;
        <D.17603>:
        {
          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.17601>;
          <D.17600>:
          D.18944 = _bmap & 1;
          if (D.18944 != 0) goto <D.18945>; else goto <D.18946>;
          <D.18945>:
          D.18947 = *_objptr;
          if (D.18947 != 0B) goto <D.18948>; else goto <D.18949>;
          <D.18948>:
          D.18947 = *_objptr;
          D.18950 = MEM[(mword *)D.18947];
          D.18951 = D.18950 & 4294967292;
          if (D.18951 == 0) goto <D.18952>; else goto <D.18953>;
          <D.18952>:
          _objptr.103 = (int) _objptr;
          start.84 = (int) start;
          D.18955 = _objptr.103 - start.84;
          D.18956 = sgen_safe_object_get_size (start);
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18955, D.18956);
          <D.17599>:
          goto <D.17599>;
          <D.18953>:
          <D.18949>:
          <D.18946>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17601>:
          if (_bmap != 0) goto <D.17600>; else goto <D.17602>;
          <D.17602>:
          _objptr = start_run + 128;
        }
        <D.17604>:
        bwords.104 = bwords;
        bwords = bwords.104 + 4294967295;
        if (bwords.104 != 0) goto <D.17603>; else goto <D.17605>;
        <D.17605>:
        el_size.105 = (sizetype) el_size;
        e_start = e_start + el_size.105;
      }
      <D.17607>:
      if (e_start < e_end) goto <D.17606>; else goto <D.17608>;
      <D.17608>:
    }
    goto <D.17523>;
    <D.17609>:
    goto <D.17523>;
    <D.17610>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17523>:
  }
}


check_object (char * start)
{
  unsigned int D.18962;
  unsigned int D.18963;
  unsigned int D.18964;
  unsigned int D.18965;
  unsigned int D.18968;
  unsigned int D.18969;
  unsigned int D.18970;
  unsigned int D.18971;
  unsigned int D.18972;
  void * D.18973;
  const char * D.18976;
  _Bool D.18977;
  long int D.18978;
  long int D.18979;
  const char * D.18984;
  _Bool D.18985;
  long int D.18986;
  long int D.18987;
  unsigned int _index.106;
  unsigned int D.18991;
  int D.18992;
  void * D.18993;
  const char * D.18996;
  _Bool D.18997;
  long int D.18998;
  long int D.18999;
  unsigned int _index.107;
  unsigned int D.19003;
  int D.19004;
  const char * D.19007;
  _Bool D.19008;
  long int D.19009;
  long int D.19010;
  unsigned int D.19013;
  unsigned int D.19016;
  int D.19017;
  int desc.108;
  unsigned int D.19021;
  unsigned int el_size.109;
  unsigned int D.19023;
  void * D.19024;
  const char * D.19027;
  _Bool D.19028;
  long int D.19029;
  long int D.19030;
  int D.19036;
  unsigned int offset.110;
  unsigned int D.19038;
  unsigned int i.111;
  unsigned int D.19040;
  void * * D.19041;
  void * D.19042;
  const char * D.19045;
  _Bool D.19046;
  long int D.19047;
  long int D.19048;
  sizetype el_size.112;
  unsigned int D.19055;
  void * D.19058;
  const char * D.19061;
  _Bool D.19062;
  long int D.19063;
  long int D.19064;
  unsigned int D.19067;
  void * D.19070;
  const char * D.19073;
  _Bool D.19074;
  long int D.19075;
  long int D.19076;
  unsigned int D.19079;
  unsigned int D.19080;
  struct MonoVTable * D.19083;
  struct MonoClass * D.19084;
  const char * D.19085;
  const char * D.19086;
  gsize * bitmap_data.113;
  unsigned int D.19088;
  void * D.19091;
  const char * D.19094;
  _Bool D.19095;
  long int D.19096;
  long int D.19097;
  int bwords.114;
  unsigned int D.19101;
  gsize * mbitmap_data.115;
  unsigned int D.19103;
  unsigned int D.19104;
  struct MonoClass * D.19105;
  unsigned int el_size.116;
  unsigned int D.19107;
  const char * D.19110;
  const char * D.19111;
  gsize * bitmap_data.117;
  unsigned int D.19113;
  void * D.19116;
  const char * D.19119;
  _Bool D.19120;
  long int D.19121;
  long int D.19122;
  unsigned int bwords.118;
  sizetype el_size.119;

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

    D.18962 = MEM[(mword *)start];
    D.18963 = D.18962 & 4294967292;
    vt = (struct GCVTable *) D.18963;
    desc = vt->desc;
    D.18964 = desc & 7;
    switch (D.18964) <default: <D.17704>, case 1: <D.17619>, case 2: <D.17626>, case 3: <D.17670>, case 4: <D.17634>, case 5: <D.17664>, case 6: <D.17683>, case 7: <D.17703>>
    <D.17619>:
    D.18965 = desc & 4294901760;
    if (D.18965 != 0) goto <D.18966>; else goto <D.18967>;
    <D.18966>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.18968 = desc >> 16;
      D.18969 = D.18968 & 255;
      D.18970 = D.18969 * 4;
      _objptr = _objptr + D.18970;
      D.18971 = desc >> 24;
      D.18972 = D.18971 * 4;
      _objptr_end = _objptr + D.18972;
      D.18973 = *_objptr;
      if (D.18973 != 0B) goto <D.18974>; else goto <D.18975>;
      <D.18974>:
      D.18973 = *_objptr;
      D.18976 = sgen_safe_name (D.18973);
      D.18977 = D.18976 == 0B;
      D.18978 = (long int) D.18977;
      D.18979 = __builtin_expect (D.18978, 0);
      if (D.18979 != 0) goto <D.18980>; else goto <D.18981>;
      <D.18980>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_safe_name (*(_objptr)) != NULL");
      <D.18981>:
      <D.18975>:
      _objptr = _objptr + 4;
      goto <D.17623>;
      <D.17622>:
      D.18973 = *_objptr;
      if (D.18973 != 0B) goto <D.18982>; else goto <D.18983>;
      <D.18982>:
      D.18973 = *_objptr;
      D.18984 = sgen_safe_name (D.18973);
      D.18985 = D.18984 == 0B;
      D.18986 = (long int) D.18985;
      D.18987 = __builtin_expect (D.18986, 0);
      if (D.18987 != 0) goto <D.18988>; else goto <D.18989>;
      <D.18988>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_safe_name (*(_objptr)) != NULL");
      <D.18989>:
      <D.18983>:
      _objptr = _objptr + 4;
      <D.17623>:
      if (_objptr < _objptr_end) goto <D.17622>; else goto <D.17624>;
      <D.17624>:
    }
    <D.18967>:
    goto <D.17625>;
    <D.17626>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.106 = (unsigned int) _index;
        D.18991 = _index.106 * 4;
        _objptr = _objptr + D.18991;
        D.18992 = _index + 1;
        _bmap = _bmap >> D.18992;
        D.18993 = *_objptr;
        if (D.18993 != 0B) goto <D.18994>; else goto <D.18995>;
        <D.18994>:
        D.18993 = *_objptr;
        D.18996 = sgen_safe_name (D.18993);
        D.18997 = D.18996 == 0B;
        D.18998 = (long int) D.18997;
        D.18999 = __builtin_expect (D.18998, 0);
        if (D.18999 != 0) goto <D.19000>; else goto <D.19001>;
        <D.19000>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_safe_name (*(_objptr)) != NULL");
        <D.19001>:
        <D.18995>:
        _objptr = _objptr + 4;
      }
      goto <D.17632>;
      <D.17631>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.107 = (unsigned int) _index;
        D.19003 = _index.107 * 4;
        _objptr = _objptr + D.19003;
        D.19004 = _index + 1;
        _bmap = _bmap >> D.19004;
        D.18993 = *_objptr;
        if (D.18993 != 0B) goto <D.19005>; else goto <D.19006>;
        <D.19005>:
        D.18993 = *_objptr;
        D.19007 = sgen_safe_name (D.18993);
        D.19008 = D.19007 == 0B;
        D.19009 = (long int) D.19008;
        D.19010 = __builtin_expect (D.19009, 0);
        if (D.19010 != 0) goto <D.19011>; else goto <D.19012>;
        <D.19011>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_safe_name (*(_objptr)) != NULL");
        <D.19012>:
        <D.19006>:
        _objptr = _objptr + 4;
      }
      <D.17632>:
      if (_bmap != 0) goto <D.17631>; else goto <D.17633>;
      <D.17633>:
    }
    goto <D.17625>;
    <D.17634>:
    D.19013 = desc & 4294950912;
    if (D.19013 != 0) goto <D.19014>; else goto <D.19015>;
    <D.19014>:
    {
      int el_size;
      int etype;

      D.19016 = desc >> 3;
      D.19017 = (int) D.19016;
      el_size = D.19017 & 1023;
      desc.108 = (int) desc;
      etype = desc.108 & 49152;
      if (etype == 16384) goto <D.19019>; else goto <D.19020>;
      <D.19019>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.19021 = MEM[(struct MonoArray *)start].max_length;
        el_size.109 = (unsigned int) el_size;
        D.19023 = D.19021 * el_size.109;
        end_refs = p + D.19023;
        goto <D.17640>;
        <D.17639>:
        D.19024 = *p;
        if (D.19024 != 0B) goto <D.19025>; else goto <D.19026>;
        <D.19025>:
        D.19024 = *p;
        D.19027 = sgen_safe_name (D.19024);
        D.19028 = D.19027 == 0B;
        D.19029 = (long int) D.19028;
        D.19030 = __builtin_expect (D.19029, 0);
        if (D.19030 != 0) goto <D.19031>; else goto <D.19032>;
        <D.19031>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p)) != NULL");
        <D.19032>:
        <D.19026>:
        p = p + 4;
        <D.17640>:
        if (p < end_refs) goto <D.17639>; else goto <D.17641>;
        <D.17641>:
      }
      goto <D.19033>;
      <D.19020>:
      if (etype == 32768) goto <D.19034>; else goto <D.19035>;
      <D.19034>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.18968 = desc >> 16;
        D.19036 = (int) D.18968;
        offset = D.19036 & 255;
        D.18971 = desc >> 24;
        num_refs = (int) D.18971;
        e_start = start + 16;
        D.19021 = MEM[(struct MonoArray *)start].max_length;
        el_size.109 = (unsigned int) el_size;
        D.19023 = D.19021 * el_size.109;
        e_end = e_start + D.19023;
        goto <D.17652>;
        <D.17651>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.110 = (unsigned int) offset;
          D.19038 = offset.110 * 4;
          p = p + D.19038;
          i = 0;
          goto <D.17649>;
          <D.17648>:
          i.111 = (unsigned int) i;
          D.19040 = i.111 * 4;
          D.19041 = p + D.19040;
          D.19042 = *D.19041;
          if (D.19042 != 0B) goto <D.19043>; else goto <D.19044>;
          <D.19043>:
          i.111 = (unsigned int) i;
          D.19040 = i.111 * 4;
          D.19041 = p + D.19040;
          D.19042 = *D.19041;
          D.19045 = sgen_safe_name (D.19042);
          D.19046 = D.19045 == 0B;
          D.19047 = (long int) D.19046;
          D.19048 = __builtin_expect (D.19047, 0);
          if (D.19048 != 0) goto <D.19049>; else goto <D.19050>;
          <D.19049>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p + i)) != NULL");
          <D.19050>:
          <D.19044>:
          i = i + 1;
          <D.17649>:
          if (i < num_refs) goto <D.17648>; else goto <D.17650>;
          <D.17650>:
          el_size.112 = (sizetype) el_size;
          e_start = e_start + el_size.112;
        }
        <D.17652>:
        if (e_start < e_end) goto <D.17651>; else goto <D.17653>;
        <D.17653>:
      }
      goto <D.19052>;
      <D.19035>:
      if (etype == 49152) goto <D.19053>; else goto <D.19054>;
      <D.19053>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.19021 = MEM[(struct MonoArray *)start].max_length;
        el_size.109 = (unsigned int) el_size;
        D.19023 = D.19021 * el_size.109;
        e_end = e_start + D.19023;
        goto <D.17662>;
        <D.17661>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17659>;
          <D.17658>:
          D.19055 = _bmap & 1;
          if (D.19055 != 0) goto <D.19056>; else goto <D.19057>;
          <D.19056>:
          D.19058 = *p;
          if (D.19058 != 0B) goto <D.19059>; else goto <D.19060>;
          <D.19059>:
          D.19058 = *p;
          D.19061 = sgen_safe_name (D.19058);
          D.19062 = D.19061 == 0B;
          D.19063 = (long int) D.19062;
          D.19064 = __builtin_expect (D.19063, 0);
          if (D.19064 != 0) goto <D.19065>; else goto <D.19066>;
          <D.19065>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p)) != NULL");
          <D.19066>:
          <D.19060>:
          <D.19057>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17659>:
          if (_bmap != 0) goto <D.17658>; else goto <D.17660>;
          <D.17660>:
          el_size.112 = (sizetype) el_size;
          e_start = e_start + el_size.112;
        }
        <D.17662>:
        if (e_start < e_end) goto <D.17661>; else goto <D.17663>;
        <D.17663>:
      }
      <D.19054>:
      <D.19052>:
      <D.19033>:
    }
    <D.19015>:
    goto <D.17625>;
    <D.17664>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17668>;
      <D.17667>:
      D.19067 = _bmap & 1;
      if (D.19067 != 0) goto <D.19068>; else goto <D.19069>;
      <D.19068>:
      D.19070 = *_objptr;
      if (D.19070 != 0B) goto <D.19071>; else goto <D.19072>;
      <D.19071>:
      D.19070 = *_objptr;
      D.19073 = sgen_safe_name (D.19070);
      D.19074 = D.19073 == 0B;
      D.19075 = (long int) D.19074;
      D.19076 = __builtin_expect (D.19075, 0);
      if (D.19076 != 0) goto <D.19077>; else goto <D.19078>;
      <D.19077>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "sgen_safe_name (*(_objptr)) != NULL");
      <D.19078>:
      <D.19072>:
      <D.19069>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17668>:
      if (_bmap != 0) goto <D.17667>; else goto <D.17669>;
      <D.17669>:
    }
    goto <D.17625>;
    <D.17670>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19079 = *bitmap_data;
      D.19080 = D.19079 + 4294967295;
      bwords = (int) D.19080;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.19081>; else goto <D.19082>;
      <D.19081>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19083 = myobj->vtable;
        D.19084 = D.19083->klass;
        D.19085 = D.19084->name_space;
        D.19083 = myobj->vtable;
        D.19084 = D.19083->klass;
        D.19086 = D.19084->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19085, D.19086);
      }
      <D.19082>:
      goto <D.17681>;
      <D.17680>:
      {
        gsize _bmap;

        bitmap_data.113 = bitmap_data;
        bitmap_data = bitmap_data.113 + 4;
        _bmap = *bitmap_data.113;
        _objptr = start_run;
        goto <D.17678>;
        <D.17677>:
        D.19088 = _bmap & 1;
        if (D.19088 != 0) goto <D.19089>; else goto <D.19090>;
        <D.19089>:
        D.19091 = *_objptr;
        if (D.19091 != 0B) goto <D.19092>; else goto <D.19093>;
        <D.19092>:
        D.19091 = *_objptr;
        D.19094 = sgen_safe_name (D.19091);
        D.19095 = D.19094 == 0B;
        D.19096 = (long int) D.19095;
        D.19097 = __builtin_expect (D.19096, 0);
        if (D.19097 != 0) goto <D.19098>; else goto <D.19099>;
        <D.19098>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "sgen_safe_name (*(_objptr)) != NULL");
        <D.19099>:
        <D.19093>:
        <D.19090>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17678>:
        if (_bmap != 0) goto <D.17677>; else goto <D.17679>;
        <D.17679>:
        start_run = start_run + 128;
      }
      <D.17681>:
      bwords.114 = bwords;
      bwords = bwords.114 + -1;
      if (bwords.114 > 0) goto <D.17680>; else goto <D.17682>;
      <D.17682>:
    }
    goto <D.17625>;
    <D.17683>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19101 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19101);
      mbitmap_data.115 = mbitmap_data;
      mbitmap_data = mbitmap_data.115 + 4;
      D.19103 = *mbitmap_data.115;
      D.19104 = D.19103 + 4294967295;
      mbwords = (int) D.19104;
      D.19105 = vt->klass;
      el_size = mono_array_element_size (D.19105);
      e_start = start + 16;
      D.19021 = MEM[(struct MonoArray *)start].max_length;
      el_size.116 = (unsigned int) el_size;
      D.19107 = D.19021 * el_size.116;
      e_end = e_start + D.19107;
      if (0 != 0) goto <D.19108>; else goto <D.19109>;
      <D.19108>:
      D.19101 = vt->desc;
      D.19105 = vt->klass;
      D.19110 = D.19105->name_space;
      D.19105 = vt->klass;
      D.19111 = D.19105->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19101, D.19110, D.19111);
      <D.19109>:
      goto <D.17701>;
      <D.17700>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.17698>;
        <D.17697>:
        {
          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.17695>;
          <D.17694>:
          D.19113 = _bmap & 1;
          if (D.19113 != 0) goto <D.19114>; else goto <D.19115>;
          <D.19114>:
          D.19116 = *_objptr;
          if (D.19116 != 0B) goto <D.19117>; else goto <D.19118>;
          <D.19117>:
          D.19116 = *_objptr;
          D.19119 = sgen_safe_name (D.19116);
          D.19120 = D.19119 == 0B;
          D.19121 = (long int) D.19120;
          D.19122 = __builtin_expect (D.19121, 0);
          if (D.19122 != 0) goto <D.19123>; else goto <D.19124>;
          <D.19123>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "sgen_safe_name (*(_objptr)) != NULL");
          <D.19124>:
          <D.19118>:
          <D.19115>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17695>:
          if (_bmap != 0) goto <D.17694>; else goto <D.17696>;
          <D.17696>:
          _objptr = start_run + 128;
        }
        <D.17698>:
        bwords.118 = bwords;
        bwords = bwords.118 + 4294967295;
        if (bwords.118 != 0) goto <D.17697>; else goto <D.17699>;
        <D.17699>:
        el_size.119 = (sizetype) el_size;
        e_start = e_start + el_size.119;
      }
      <D.17701>:
      if (e_start < e_end) goto <D.17700>; else goto <D.17702>;
      <D.17702>:
    }
    goto <D.17625>;
    <D.17703>:
    goto <D.17625>;
    <D.17704>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17625>:
  }
}


sgen_check_whole_heap (gboolean allow_missing_pinned)
{
  struct GCMemSection * nursery_section.120;
  char * D.19130;
  char * D.19131;
  void * allow_missing_pinned.121;
  void (*<T2c3e>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.19133;
  int broken_heap.122;
  _Bool D.19135;
  long int D.19136;
  long int D.19137;

  setup_valid_nursery_objects ();
  broken_heap = 0;
  nursery_section.120 = nursery_section;
  D.19130 = nursery_section.120->data;
  nursery_section.120 = nursery_section;
  D.19131 = nursery_section.120->end_data;
  allow_missing_pinned.121 = (void *) allow_missing_pinned;
  sgen_scan_area_with_callback (D.19130, D.19131, verify_object_pointers_callback, allow_missing_pinned.121, 0);
  D.19133 = major_collector.iterate_objects;
  allow_missing_pinned.121 = (void *) allow_missing_pinned;
  D.19133 (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.19135 = broken_heap.122 != 0;
  D.19136 = (long int) D.19135;
  D.19137 = __builtin_expect (D.19136, 0);
  if (D.19137 != 0) goto <D.19138>; else goto <D.19139>;
  <D.19138>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 445, "!broken_heap");
  <D.19139>:
}


verify_object_pointers_callback (char * start, size_t size, void * data)
{
  unsigned int D.19140;
  unsigned int D.19141;
  unsigned int D.19142;
  unsigned int D.19143;
  unsigned int D.19146;
  unsigned int D.19147;
  unsigned int D.19148;
  unsigned int D.19149;
  unsigned int D.19150;
  char * D.19151;
  int D.19154;
  int D.19158;
  void * D.19161;
  int D.19162;
  struct SgenRemeberedSet * D.19167;
  gboolean (*<T2be4>) (char *) D.19168;
  int D.19169;
  int D.19172;
  unsigned int D.19176;
  unsigned int D.19177;
  int D.19180;
  int D.19184;
  int D.19187;
  struct SgenRemeberedSet * D.19192;
  gboolean (*<T2be4>) (char *) D.19193;
  int D.19194;
  int D.19197;
  unsigned int _index.123;
  unsigned int D.19202;
  int D.19203;
  char * D.19204;
  int D.19207;
  int D.19211;
  void * D.19214;
  int D.19215;
  struct SgenRemeberedSet * D.19220;
  gboolean (*<T2be4>) (char *) D.19221;
  int D.19222;
  int D.19225;
  unsigned int D.19229;
  unsigned int D.19230;
  unsigned int _index.124;
  unsigned int D.19232;
  int D.19233;
  int D.19236;
  int D.19240;
  int D.19243;
  struct SgenRemeberedSet * D.19248;
  gboolean (*<T2be4>) (char *) D.19249;
  int D.19250;
  int D.19253;
  unsigned int D.19257;
  unsigned int D.19260;
  int D.19261;
  int desc.125;
  unsigned int D.19265;
  unsigned int el_size.126;
  unsigned int D.19267;
  char * D.19268;
  int D.19271;
  int D.19275;
  void * D.19278;
  int D.19279;
  struct SgenRemeberedSet * D.19284;
  gboolean (*<T2be4>) (char *) D.19285;
  int D.19286;
  int D.19289;
  unsigned int D.19293;
  unsigned int D.19294;
  int D.19298;
  unsigned int offset.127;
  unsigned int D.19300;
  char * D.19301;
  sizetype i.128;
  char * D.19303;
  int D.19306;
  unsigned int i.129;
  unsigned int D.19310;
  char * * D.19311;
  int D.19313;
  void * D.19316;
  void * D.19317;
  int D.19318;
  struct SgenRemeberedSet * D.19323;
  gboolean (*<T2be4>) (char *) D.19324;
  char * D.19325;
  int D.19326;
  void * * D.19329;
  void * D.19330;
  int D.19331;
  unsigned int D.19335;
  unsigned int D.19336;
  sizetype el_size.130;
  unsigned int D.19341;
  char * D.19344;
  int D.19347;
  int D.19351;
  void * D.19354;
  int D.19355;
  struct SgenRemeberedSet * D.19360;
  gboolean (*<T2be4>) (char *) D.19361;
  int D.19362;
  int D.19365;
  unsigned int D.19369;
  unsigned int D.19370;
  unsigned int D.19371;
  char * D.19374;
  int D.19377;
  int D.19381;
  void * D.19384;
  int D.19385;
  struct SgenRemeberedSet * D.19390;
  gboolean (*<T2be4>) (char *) D.19391;
  int D.19392;
  int D.19395;
  unsigned int D.19399;
  unsigned int D.19400;
  unsigned int D.19401;
  unsigned int D.19402;
  struct MonoVTable * D.19405;
  struct MonoClass * D.19406;
  const char * D.19407;
  const char * D.19408;
  gsize * bitmap_data.131;
  unsigned int D.19410;
  char * D.19413;
  int D.19416;
  int D.19420;
  void * D.19423;
  int D.19424;
  struct SgenRemeberedSet * D.19429;
  gboolean (*<T2be4>) (char *) D.19430;
  int D.19431;
  int D.19434;
  unsigned int D.19438;
  unsigned int D.19439;
  int bwords.132;
  unsigned int D.19441;
  gsize * mbitmap_data.133;
  unsigned int D.19443;
  unsigned int D.19444;
  struct MonoClass * D.19445;
  unsigned int el_size.134;
  unsigned int D.19447;
  const char * D.19450;
  const char * D.19451;
  gsize * bitmap_data.135;
  unsigned int D.19453;
  char * D.19456;
  int D.19459;
  int D.19463;
  void * D.19466;
  int D.19467;
  struct SgenRemeberedSet * D.19472;
  gboolean (*<T2be4>) (char *) D.19473;
  int D.19474;
  int D.19477;
  unsigned int D.19481;
  unsigned int D.19482;
  unsigned int bwords.136;
  sizetype el_size.137;
  gboolean allow_missing_pinned;

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

    D.19140 = MEM[(mword *)start];
    D.19141 = D.19140 & 4294967292;
    vt = (struct GCVTable *) D.19141;
    desc = vt->desc;
    D.19142 = desc & 7;
    switch (D.19142) <default: <D.17842>, case 1: <D.17757>, case 2: <D.17764>, case 3: <D.17808>, case 4: <D.17772>, case 5: <D.17802>, case 6: <D.17821>, case 7: <D.17841>>
    <D.17757>:
    D.19143 = desc & 4294901760;
    if (D.19143 != 0) goto <D.19144>; else goto <D.19145>;
    <D.19144>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19146 = desc >> 16;
      D.19147 = D.19146 & 255;
      D.19148 = D.19147 * 4;
      _objptr = _objptr + D.19148;
      D.19149 = desc >> 24;
      D.19150 = D.19149 * 4;
      _objptr_end = _objptr + D.19150;
      D.19151 = MEM[(char * *)_objptr];
      if (D.19151 != 0B) goto <D.19152>; else goto <D.19153>;
      <D.19152>:
      D.19151 = MEM[(char * *)_objptr];
      D.19154 = is_valid_object_pointer (D.19151);
      if (D.19154 == 0) goto <D.19155>; else goto <D.19156>;
      <D.19155>:
      bad_pointer_spew (start, _objptr);
      goto <D.19157>;
      <D.19156>:
      D.19158 = sgen_ptr_in_nursery (start);
      if (D.19158 == 0) goto <D.19159>; else goto <D.19160>;
      <D.19159>:
      D.19161 = *_objptr;
      D.19162 = sgen_ptr_in_nursery (D.19161);
      if (D.19162 != 0) goto <D.19163>; else goto <D.19164>;
      <D.19163>:
      D.19167 = sgen_get_remset ();
      D.19168 = D.19167->find_address;
      D.19169 = D.19168 (_objptr);
      if (D.19169 == 0) goto <D.19170>; else goto <D.19171>;
      <D.19170>:
      D.19161 = *_objptr;
      D.19172 = sgen_cement_lookup (D.19161);
      if (D.19172 == 0) goto <D.19173>; else goto <D.19174>;
      <D.19173>:
      if (allow_missing_pinned == 0) goto <D.19165>; else goto <D.19175>;
      <D.19175>:
      D.19161 = *_objptr;
      D.19176 = MEM[(mword *)D.19161];
      D.19177 = D.19176 & 2;
      if (D.19177 == 0) goto <D.19165>; else goto <D.19166>;
      <D.19165>:
      missing_remset_spew (start, _objptr);
      <D.19166>:
      <D.19174>:
      <D.19171>:
      <D.19164>:
      <D.19160>:
      <D.19157>:
      <D.19153>:
      _objptr = _objptr + 4;
      goto <D.17761>;
      <D.17760>:
      D.19151 = MEM[(char * *)_objptr];
      if (D.19151 != 0B) goto <D.19178>; else goto <D.19179>;
      <D.19178>:
      D.19151 = MEM[(char * *)_objptr];
      D.19180 = is_valid_object_pointer (D.19151);
      if (D.19180 == 0) goto <D.19181>; else goto <D.19182>;
      <D.19181>:
      bad_pointer_spew (start, _objptr);
      goto <D.19183>;
      <D.19182>:
      D.19184 = sgen_ptr_in_nursery (start);
      if (D.19184 == 0) goto <D.19185>; else goto <D.19186>;
      <D.19185>:
      D.19161 = *_objptr;
      D.19187 = sgen_ptr_in_nursery (D.19161);
      if (D.19187 != 0) goto <D.19188>; else goto <D.19189>;
      <D.19188>:
      D.19192 = sgen_get_remset ();
      D.19193 = D.19192->find_address;
      D.19194 = D.19193 (_objptr);
      if (D.19194 == 0) goto <D.19195>; else goto <D.19196>;
      <D.19195>:
      D.19161 = *_objptr;
      D.19197 = sgen_cement_lookup (D.19161);
      if (D.19197 == 0) goto <D.19198>; else goto <D.19199>;
      <D.19198>:
      if (allow_missing_pinned == 0) goto <D.19190>; else goto <D.19200>;
      <D.19200>:
      D.19161 = *_objptr;
      D.19176 = MEM[(mword *)D.19161];
      D.19177 = D.19176 & 2;
      if (D.19177 == 0) goto <D.19190>; else goto <D.19191>;
      <D.19190>:
      missing_remset_spew (start, _objptr);
      <D.19191>:
      <D.19199>:
      <D.19196>:
      <D.19189>:
      <D.19186>:
      <D.19183>:
      <D.19179>:
      _objptr = _objptr + 4;
      <D.17761>:
      if (_objptr < _objptr_end) goto <D.17760>; else goto <D.17762>;
      <D.17762>:
    }
    <D.19145>:
    goto <D.17763>;
    <D.17764>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.123 = (unsigned int) _index;
        D.19202 = _index.123 * 4;
        _objptr = _objptr + D.19202;
        D.19203 = _index + 1;
        _bmap = _bmap >> D.19203;
        D.19204 = MEM[(char * *)_objptr];
        if (D.19204 != 0B) goto <D.19205>; else goto <D.19206>;
        <D.19205>:
        D.19204 = MEM[(char * *)_objptr];
        D.19207 = is_valid_object_pointer (D.19204);
        if (D.19207 == 0) goto <D.19208>; else goto <D.19209>;
        <D.19208>:
        bad_pointer_spew (start, _objptr);
        goto <D.19210>;
        <D.19209>:
        D.19211 = sgen_ptr_in_nursery (start);
        if (D.19211 == 0) goto <D.19212>; else goto <D.19213>;
        <D.19212>:
        D.19214 = *_objptr;
        D.19215 = sgen_ptr_in_nursery (D.19214);
        if (D.19215 != 0) goto <D.19216>; else goto <D.19217>;
        <D.19216>:
        D.19220 = sgen_get_remset ();
        D.19221 = D.19220->find_address;
        D.19222 = D.19221 (_objptr);
        if (D.19222 == 0) goto <D.19223>; else goto <D.19224>;
        <D.19223>:
        D.19214 = *_objptr;
        D.19225 = sgen_cement_lookup (D.19214);
        if (D.19225 == 0) goto <D.19226>; else goto <D.19227>;
        <D.19226>:
        if (allow_missing_pinned == 0) goto <D.19218>; else goto <D.19228>;
        <D.19228>:
        D.19214 = *_objptr;
        D.19229 = MEM[(mword *)D.19214];
        D.19230 = D.19229 & 2;
        if (D.19230 == 0) goto <D.19218>; else goto <D.19219>;
        <D.19218>:
        missing_remset_spew (start, _objptr);
        <D.19219>:
        <D.19227>:
        <D.19224>:
        <D.19217>:
        <D.19213>:
        <D.19210>:
        <D.19206>:
        _objptr = _objptr + 4;
      }
      goto <D.17770>;
      <D.17769>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.124 = (unsigned int) _index;
        D.19232 = _index.124 * 4;
        _objptr = _objptr + D.19232;
        D.19233 = _index + 1;
        _bmap = _bmap >> D.19233;
        D.19204 = MEM[(char * *)_objptr];
        if (D.19204 != 0B) goto <D.19234>; else goto <D.19235>;
        <D.19234>:
        D.19204 = MEM[(char * *)_objptr];
        D.19236 = is_valid_object_pointer (D.19204);
        if (D.19236 == 0) goto <D.19237>; else goto <D.19238>;
        <D.19237>:
        bad_pointer_spew (start, _objptr);
        goto <D.19239>;
        <D.19238>:
        D.19240 = sgen_ptr_in_nursery (start);
        if (D.19240 == 0) goto <D.19241>; else goto <D.19242>;
        <D.19241>:
        D.19214 = *_objptr;
        D.19243 = sgen_ptr_in_nursery (D.19214);
        if (D.19243 != 0) goto <D.19244>; else goto <D.19245>;
        <D.19244>:
        D.19248 = sgen_get_remset ();
        D.19249 = D.19248->find_address;
        D.19250 = D.19249 (_objptr);
        if (D.19250 == 0) goto <D.19251>; else goto <D.19252>;
        <D.19251>:
        D.19214 = *_objptr;
        D.19253 = sgen_cement_lookup (D.19214);
        if (D.19253 == 0) goto <D.19254>; else goto <D.19255>;
        <D.19254>:
        if (allow_missing_pinned == 0) goto <D.19246>; else goto <D.19256>;
        <D.19256>:
        D.19214 = *_objptr;
        D.19229 = MEM[(mword *)D.19214];
        D.19230 = D.19229 & 2;
        if (D.19230 == 0) goto <D.19246>; else goto <D.19247>;
        <D.19246>:
        missing_remset_spew (start, _objptr);
        <D.19247>:
        <D.19255>:
        <D.19252>:
        <D.19245>:
        <D.19242>:
        <D.19239>:
        <D.19235>:
        _objptr = _objptr + 4;
      }
      <D.17770>:
      if (_bmap != 0) goto <D.17769>; else goto <D.17771>;
      <D.17771>:
    }
    goto <D.17763>;
    <D.17772>:
    D.19257 = desc & 4294950912;
    if (D.19257 != 0) goto <D.19258>; else goto <D.19259>;
    <D.19258>:
    {
      int el_size;
      int etype;

      D.19260 = desc >> 3;
      D.19261 = (int) D.19260;
      el_size = D.19261 & 1023;
      desc.125 = (int) desc;
      etype = desc.125 & 49152;
      if (etype == 16384) goto <D.19263>; else goto <D.19264>;
      <D.19263>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.19265 = MEM[(struct MonoArray *)start].max_length;
        el_size.126 = (unsigned int) el_size;
        D.19267 = D.19265 * el_size.126;
        end_refs = p + D.19267;
        goto <D.17778>;
        <D.17777>:
        D.19268 = MEM[(char * *)p];
        if (D.19268 != 0B) goto <D.19269>; else goto <D.19270>;
        <D.19269>:
        D.19268 = MEM[(char * *)p];
        D.19271 = is_valid_object_pointer (D.19268);
        if (D.19271 == 0) goto <D.19272>; else goto <D.19273>;
        <D.19272>:
        bad_pointer_spew (start, p);
        goto <D.19274>;
        <D.19273>:
        D.19275 = sgen_ptr_in_nursery (start);
        if (D.19275 == 0) goto <D.19276>; else goto <D.19277>;
        <D.19276>:
        D.19278 = *p;
        D.19279 = sgen_ptr_in_nursery (D.19278);
        if (D.19279 != 0) goto <D.19280>; else goto <D.19281>;
        <D.19280>:
        D.19284 = sgen_get_remset ();
        D.19285 = D.19284->find_address;
        D.19286 = D.19285 (p);
        if (D.19286 == 0) goto <D.19287>; else goto <D.19288>;
        <D.19287>:
        D.19278 = *p;
        D.19289 = sgen_cement_lookup (D.19278);
        if (D.19289 == 0) goto <D.19290>; else goto <D.19291>;
        <D.19290>:
        if (allow_missing_pinned == 0) goto <D.19282>; else goto <D.19292>;
        <D.19292>:
        D.19278 = *p;
        D.19293 = MEM[(mword *)D.19278];
        D.19294 = D.19293 & 2;
        if (D.19294 == 0) goto <D.19282>; else goto <D.19283>;
        <D.19282>:
        missing_remset_spew (start, p);
        <D.19283>:
        <D.19291>:
        <D.19288>:
        <D.19281>:
        <D.19277>:
        <D.19274>:
        <D.19270>:
        p = p + 4;
        <D.17778>:
        if (p < end_refs) goto <D.17777>; else goto <D.17779>;
        <D.17779>:
      }
      goto <D.19295>;
      <D.19264>:
      if (etype == 32768) goto <D.19296>; else goto <D.19297>;
      <D.19296>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19146 = desc >> 16;
        D.19298 = (int) D.19146;
        offset = D.19298 & 255;
        D.19149 = desc >> 24;
        num_refs = (int) D.19149;
        e_start = start + 16;
        D.19265 = MEM[(struct MonoArray *)start].max_length;
        el_size.126 = (unsigned int) el_size;
        D.19267 = D.19265 * el_size.126;
        e_end = e_start + D.19267;
        goto <D.17790>;
        <D.17789>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.127 = (unsigned int) offset;
          D.19300 = offset.127 * 4;
          p = p + D.19300;
          i = 0;
          goto <D.17787>;
          <D.17786>:
          D.19301 = MEM[(char * *)p];
          i.128 = (sizetype) i;
          D.19303 = D.19301 + i.128;
          if (D.19303 != 0B) goto <D.19304>; else goto <D.19305>;
          <D.19304>:
          D.19301 = MEM[(char * *)p];
          i.128 = (sizetype) i;
          D.19303 = D.19301 + i.128;
          D.19306 = is_valid_object_pointer (D.19303);
          if (D.19306 == 0) goto <D.19307>; else goto <D.19308>;
          <D.19307>:
          i.129 = (unsigned int) i;
          D.19310 = i.129 * 4;
          D.19311 = p + D.19310;
          bad_pointer_spew (start, D.19311);
          goto <D.19312>;
          <D.19308>:
          D.19313 = sgen_ptr_in_nursery (start);
          if (D.19313 == 0) goto <D.19314>; else goto <D.19315>;
          <D.19314>:
          D.19316 = *p;
          i.128 = (sizetype) i;
          D.19317 = D.19316 + i.128;
          D.19318 = sgen_ptr_in_nursery (D.19317);
          if (D.19318 != 0) goto <D.19319>; else goto <D.19320>;
          <D.19319>:
          D.19323 = sgen_get_remset ();
          D.19324 = D.19323->find_address;
          i.129 = (unsigned int) i;
          D.19310 = i.129 * 4;
          D.19325 = p + D.19310;
          D.19326 = D.19324 (D.19325);
          if (D.19326 == 0) goto <D.19327>; else goto <D.19328>;
          <D.19327>:
          i.129 = (unsigned int) i;
          D.19310 = i.129 * 4;
          D.19329 = p + D.19310;
          D.19330 = *D.19329;
          D.19331 = sgen_cement_lookup (D.19330);
          if (D.19331 == 0) goto <D.19332>; else goto <D.19333>;
          <D.19332>:
          if (allow_missing_pinned == 0) goto <D.19321>; else goto <D.19334>;
          <D.19334>:
          i.129 = (unsigned int) i;
          D.19310 = i.129 * 4;
          D.19329 = p + D.19310;
          D.19330 = *D.19329;
          D.19335 = MEM[(mword *)D.19330];
          D.19336 = D.19335 & 2;
          if (D.19336 == 0) goto <D.19321>; else goto <D.19322>;
          <D.19321>:
          i.129 = (unsigned int) i;
          D.19310 = i.129 * 4;
          D.19311 = p + D.19310;
          missing_remset_spew (start, D.19311);
          <D.19322>:
          <D.19333>:
          <D.19328>:
          <D.19320>:
          <D.19315>:
          <D.19312>:
          <D.19305>:
          i = i + 1;
          <D.17787>:
          if (i < num_refs) goto <D.17786>; else goto <D.17788>;
          <D.17788>:
          el_size.130 = (sizetype) el_size;
          e_start = e_start + el_size.130;
        }
        <D.17790>:
        if (e_start < e_end) goto <D.17789>; else goto <D.17791>;
        <D.17791>:
      }
      goto <D.19338>;
      <D.19297>:
      if (etype == 49152) goto <D.19339>; else goto <D.19340>;
      <D.19339>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.19265 = MEM[(struct MonoArray *)start].max_length;
        el_size.126 = (unsigned int) el_size;
        D.19267 = D.19265 * el_size.126;
        e_end = e_start + D.19267;
        goto <D.17800>;
        <D.17799>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17797>;
          <D.17796>:
          D.19341 = _bmap & 1;
          if (D.19341 != 0) goto <D.19342>; else goto <D.19343>;
          <D.19342>:
          D.19344 = MEM[(char * *)p];
          if (D.19344 != 0B) goto <D.19345>; else goto <D.19346>;
          <D.19345>:
          D.19344 = MEM[(char * *)p];
          D.19347 = is_valid_object_pointer (D.19344);
          if (D.19347 == 0) goto <D.19348>; else goto <D.19349>;
          <D.19348>:
          bad_pointer_spew (start, p);
          goto <D.19350>;
          <D.19349>:
          D.19351 = sgen_ptr_in_nursery (start);
          if (D.19351 == 0) goto <D.19352>; else goto <D.19353>;
          <D.19352>:
          D.19354 = *p;
          D.19355 = sgen_ptr_in_nursery (D.19354);
          if (D.19355 != 0) goto <D.19356>; else goto <D.19357>;
          <D.19356>:
          D.19360 = sgen_get_remset ();
          D.19361 = D.19360->find_address;
          D.19362 = D.19361 (p);
          if (D.19362 == 0) goto <D.19363>; else goto <D.19364>;
          <D.19363>:
          D.19354 = *p;
          D.19365 = sgen_cement_lookup (D.19354);
          if (D.19365 == 0) goto <D.19366>; else goto <D.19367>;
          <D.19366>:
          if (allow_missing_pinned == 0) goto <D.19358>; else goto <D.19368>;
          <D.19368>:
          D.19354 = *p;
          D.19369 = MEM[(mword *)D.19354];
          D.19370 = D.19369 & 2;
          if (D.19370 == 0) goto <D.19358>; else goto <D.19359>;
          <D.19358>:
          missing_remset_spew (start, p);
          <D.19359>:
          <D.19367>:
          <D.19364>:
          <D.19357>:
          <D.19353>:
          <D.19350>:
          <D.19346>:
          <D.19343>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17797>:
          if (_bmap != 0) goto <D.17796>; else goto <D.17798>;
          <D.17798>:
          el_size.130 = (sizetype) el_size;
          e_start = e_start + el_size.130;
        }
        <D.17800>:
        if (e_start < e_end) goto <D.17799>; else goto <D.17801>;
        <D.17801>:
      }
      <D.19340>:
      <D.19338>:
      <D.19295>:
    }
    <D.19259>:
    goto <D.17763>;
    <D.17802>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17806>;
      <D.17805>:
      D.19371 = _bmap & 1;
      if (D.19371 != 0) goto <D.19372>; else goto <D.19373>;
      <D.19372>:
      D.19374 = MEM[(char * *)_objptr];
      if (D.19374 != 0B) goto <D.19375>; else goto <D.19376>;
      <D.19375>:
      D.19374 = MEM[(char * *)_objptr];
      D.19377 = is_valid_object_pointer (D.19374);
      if (D.19377 == 0) goto <D.19378>; else goto <D.19379>;
      <D.19378>:
      bad_pointer_spew (start, _objptr);
      goto <D.19380>;
      <D.19379>:
      D.19381 = sgen_ptr_in_nursery (start);
      if (D.19381 == 0) goto <D.19382>; else goto <D.19383>;
      <D.19382>:
      D.19384 = *_objptr;
      D.19385 = sgen_ptr_in_nursery (D.19384);
      if (D.19385 != 0) goto <D.19386>; else goto <D.19387>;
      <D.19386>:
      D.19390 = sgen_get_remset ();
      D.19391 = D.19390->find_address;
      D.19392 = D.19391 (_objptr);
      if (D.19392 == 0) goto <D.19393>; else goto <D.19394>;
      <D.19393>:
      D.19384 = *_objptr;
      D.19395 = sgen_cement_lookup (D.19384);
      if (D.19395 == 0) goto <D.19396>; else goto <D.19397>;
      <D.19396>:
      if (allow_missing_pinned == 0) goto <D.19388>; else goto <D.19398>;
      <D.19398>:
      D.19384 = *_objptr;
      D.19399 = MEM[(mword *)D.19384];
      D.19400 = D.19399 & 2;
      if (D.19400 == 0) goto <D.19388>; else goto <D.19389>;
      <D.19388>:
      missing_remset_spew (start, _objptr);
      <D.19389>:
      <D.19397>:
      <D.19394>:
      <D.19387>:
      <D.19383>:
      <D.19380>:
      <D.19376>:
      <D.19373>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17806>:
      if (_bmap != 0) goto <D.17805>; else goto <D.17807>;
      <D.17807>:
    }
    goto <D.17763>;
    <D.17808>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19401 = *bitmap_data;
      D.19402 = D.19401 + 4294967295;
      bwords = (int) D.19402;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.19403>; else goto <D.19404>;
      <D.19403>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19405 = myobj->vtable;
        D.19406 = D.19405->klass;
        D.19407 = D.19406->name_space;
        D.19405 = myobj->vtable;
        D.19406 = D.19405->klass;
        D.19408 = D.19406->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19407, D.19408);
      }
      <D.19404>:
      goto <D.17819>;
      <D.17818>:
      {
        gsize _bmap;

        bitmap_data.131 = bitmap_data;
        bitmap_data = bitmap_data.131 + 4;
        _bmap = *bitmap_data.131;
        _objptr = start_run;
        goto <D.17816>;
        <D.17815>:
        D.19410 = _bmap & 1;
        if (D.19410 != 0) goto <D.19411>; else goto <D.19412>;
        <D.19411>:
        D.19413 = MEM[(char * *)_objptr];
        if (D.19413 != 0B) goto <D.19414>; else goto <D.19415>;
        <D.19414>:
        D.19413 = MEM[(char * *)_objptr];
        D.19416 = is_valid_object_pointer (D.19413);
        if (D.19416 == 0) goto <D.19417>; else goto <D.19418>;
        <D.19417>:
        bad_pointer_spew (start, _objptr);
        goto <D.19419>;
        <D.19418>:
        D.19420 = sgen_ptr_in_nursery (start);
        if (D.19420 == 0) goto <D.19421>; else goto <D.19422>;
        <D.19421>:
        D.19423 = *_objptr;
        D.19424 = sgen_ptr_in_nursery (D.19423);
        if (D.19424 != 0) goto <D.19425>; else goto <D.19426>;
        <D.19425>:
        D.19429 = sgen_get_remset ();
        D.19430 = D.19429->find_address;
        D.19431 = D.19430 (_objptr);
        if (D.19431 == 0) goto <D.19432>; else goto <D.19433>;
        <D.19432>:
        D.19423 = *_objptr;
        D.19434 = sgen_cement_lookup (D.19423);
        if (D.19434 == 0) goto <D.19435>; else goto <D.19436>;
        <D.19435>:
        if (allow_missing_pinned == 0) goto <D.19427>; else goto <D.19437>;
        <D.19437>:
        D.19423 = *_objptr;
        D.19438 = MEM[(mword *)D.19423];
        D.19439 = D.19438 & 2;
        if (D.19439 == 0) goto <D.19427>; else goto <D.19428>;
        <D.19427>:
        missing_remset_spew (start, _objptr);
        <D.19428>:
        <D.19436>:
        <D.19433>:
        <D.19426>:
        <D.19422>:
        <D.19419>:
        <D.19415>:
        <D.19412>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17816>:
        if (_bmap != 0) goto <D.17815>; else goto <D.17817>;
        <D.17817>:
        start_run = start_run + 128;
      }
      <D.17819>:
      bwords.132 = bwords;
      bwords = bwords.132 + -1;
      if (bwords.132 > 0) goto <D.17818>; else goto <D.17820>;
      <D.17820>:
    }
    goto <D.17763>;
    <D.17821>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19441 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19441);
      mbitmap_data.133 = mbitmap_data;
      mbitmap_data = mbitmap_data.133 + 4;
      D.19443 = *mbitmap_data.133;
      D.19444 = D.19443 + 4294967295;
      mbwords = (int) D.19444;
      D.19445 = vt->klass;
      el_size = mono_array_element_size (D.19445);
      e_start = start + 16;
      D.19265 = MEM[(struct MonoArray *)start].max_length;
      el_size.134 = (unsigned int) el_size;
      D.19447 = D.19265 * el_size.134;
      e_end = e_start + D.19447;
      if (0 != 0) goto <D.19448>; else goto <D.19449>;
      <D.19448>:
      D.19441 = vt->desc;
      D.19445 = vt->klass;
      D.19450 = D.19445->name_space;
      D.19445 = vt->klass;
      D.19451 = D.19445->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19441, D.19450, D.19451);
      <D.19449>:
      goto <D.17839>;
      <D.17838>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.17836>;
        <D.17835>:
        {
          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.17833>;
          <D.17832>:
          D.19453 = _bmap & 1;
          if (D.19453 != 0) goto <D.19454>; else goto <D.19455>;
          <D.19454>:
          D.19456 = MEM[(char * *)_objptr];
          if (D.19456 != 0B) goto <D.19457>; else goto <D.19458>;
          <D.19457>:
          D.19456 = MEM[(char * *)_objptr];
          D.19459 = is_valid_object_pointer (D.19456);
          if (D.19459 == 0) goto <D.19460>; else goto <D.19461>;
          <D.19460>:
          bad_pointer_spew (start, _objptr);
          goto <D.19462>;
          <D.19461>:
          D.19463 = sgen_ptr_in_nursery (start);
          if (D.19463 == 0) goto <D.19464>; else goto <D.19465>;
          <D.19464>:
          D.19466 = *_objptr;
          D.19467 = sgen_ptr_in_nursery (D.19466);
          if (D.19467 != 0) goto <D.19468>; else goto <D.19469>;
          <D.19468>:
          D.19472 = sgen_get_remset ();
          D.19473 = D.19472->find_address;
          D.19474 = D.19473 (_objptr);
          if (D.19474 == 0) goto <D.19475>; else goto <D.19476>;
          <D.19475>:
          D.19466 = *_objptr;
          D.19477 = sgen_cement_lookup (D.19466);
          if (D.19477 == 0) goto <D.19478>; else goto <D.19479>;
          <D.19478>:
          if (allow_missing_pinned == 0) goto <D.19470>; else goto <D.19480>;
          <D.19480>:
          D.19466 = *_objptr;
          D.19481 = MEM[(mword *)D.19466];
          D.19482 = D.19481 & 2;
          if (D.19482 == 0) goto <D.19470>; else goto <D.19471>;
          <D.19470>:
          missing_remset_spew (start, _objptr);
          <D.19471>:
          <D.19479>:
          <D.19476>:
          <D.19469>:
          <D.19465>:
          <D.19462>:
          <D.19458>:
          <D.19455>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17833>:
          if (_bmap != 0) goto <D.17832>; else goto <D.17834>;
          <D.17834>:
          _objptr = start_run + 128;
        }
        <D.17836>:
        bwords.136 = bwords;
        bwords = bwords.136 + 4294967295;
        if (bwords.136 != 0) goto <D.17835>; else goto <D.17837>;
        <D.17837>:
        el_size.137 = (sizetype) el_size;
        e_start = e_start + el_size.137;
      }
      <D.17839>:
      if (e_start < e_end) goto <D.17838>; else goto <D.17840>;
      <D.17840>:
    }
    goto <D.17763>;
    <D.17841>:
    goto <D.17763>;
    <D.17842>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17763>:
  }
}


is_valid_object_pointer (char * object)
{
  int D.19486;
  gboolean D.19489;
  int D.19490;
  gboolean (*<T2be4>) (char *) D.19493;
  int D.19494;

  D.19486 = sgen_ptr_in_nursery (object);
  if (D.19486 != 0) goto <D.19487>; else goto <D.19488>;
  <D.19487>:
  D.19489 = find_object_in_nursery_dump (object);
  return D.19489;
  <D.19488>:
  D.19490 = sgen_los_is_valid_object (object);
  if (D.19490 != 0) goto <D.19491>; else goto <D.19492>;
  <D.19491>:
  D.19489 = 1;
  return D.19489;
  <D.19492>:
  D.19493 = major_collector.is_valid_object;
  D.19494 = D.19493 (object);
  if (D.19494 != 0) goto <D.19495>; else goto <D.19496>;
  <D.19495>:
  D.19489 = 1;
  return D.19489;
  <D.19496>:
  D.19489 = 0;
  return D.19489;
}


find_object_in_nursery_dump (char * object)
{
  int D.19498;
  int D.19499;
  char * * valid_nursery_objects.138;
  unsigned int middle.139;
  unsigned int D.19502;
  char * * D.19503;
  char * D.19504;
  gboolean D.19507;
  _Bool D.19511;
  long int D.19512;
  long int D.19513;
  int first;
  int last;

  first = 0;
  last = valid_nursery_object_count;
  goto <D.17723>;
  <D.17722>:
  {
    int middle;

    D.19498 = last - first;
    D.19499 = D.19498 >> 1;
    middle = D.19499 + first;
    valid_nursery_objects.138 = valid_nursery_objects;
    middle.139 = (unsigned int) middle;
    D.19502 = middle.139 * 4;
    D.19503 = valid_nursery_objects.138 + D.19502;
    D.19504 = *D.19503;
    if (D.19504 == object) goto <D.19505>; else goto <D.19506>;
    <D.19505>:
    D.19507 = 1;
    return D.19507;
    <D.19506>:
    valid_nursery_objects.138 = valid_nursery_objects;
    middle.139 = (unsigned int) middle;
    D.19502 = middle.139 * 4;
    D.19503 = valid_nursery_objects.138 + D.19502;
    D.19504 = *D.19503;
    if (D.19504 > object) goto <D.19508>; else goto <D.19509>;
    <D.19508>:
    last = middle;
    goto <D.19510>;
    <D.19509>:
    first = middle + 1;
    <D.19510>:
  }
  <D.17723>:
  if (first < last) goto <D.17722>; else goto <D.17724>;
  <D.17724>:
  D.19511 = first != last;
  D.19512 = (long int) D.19511;
  D.19513 = __builtin_expect (D.19512, 0);
  if (D.19513 != 0) goto <D.19514>; else goto <D.19515>;
  <D.19514>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 337, "first == last");
  <D.19515>:
  D.19507 = 0;
  return D.19507;
}


bad_pointer_spew (char * obj, char * * slot)
{
  unsigned int D.19517;
  unsigned int D.19518;
  int gc_debug_level.140;
  _Bool D.19520;
  long int D.19521;
  long int D.19522;
  struct FILE * gc_debug_file.141;
  int slot.142;
  int obj.143;
  int D.19528;
  struct MonoClass * D.19529;
  const char * D.19530;
  const char * D.19531;
  char * ptr;
  struct MonoVTable * vtable;

  ptr = *slot;
  D.19517 = MEM[(mword *)obj];
  D.19518 = D.19517 & 4294967292;
  vtable = (struct MonoVTable *) D.19518;
  gc_debug_level.140 = gc_debug_level;
  D.19520 = gc_debug_level.140 >= 0;
  D.19521 = (long int) D.19520;
  D.19522 = __builtin_expect (D.19521, 0);
  if (D.19522 != 0) goto <D.19523>; else goto <D.19524>;
  <D.19523>:
  gc_debug_file.141 = gc_debug_file;
  slot.142 = (int) slot;
  obj.143 = (int) obj;
  D.19528 = slot.142 - obj.143;
  D.19529 = vtable->klass;
  D.19530 = D.19529->name_space;
  D.19529 = vtable->klass;
  D.19531 = D.19529->name;
  fprintf (gc_debug_file.141, "Invalid object pointer %p at offset %td in object %p (%s.%s):\n", ptr, D.19528, obj, D.19530, D.19531);
  gc_debug_file.141 = gc_debug_file;
  fflush (gc_debug_file.141);
  <D.19524>:
  describe_pointer (ptr, 0);
  broken_heap = 1;
}


missing_remset_spew (char * obj, char * * slot)
{
  unsigned int D.19532;
  unsigned int D.19533;
  int gc_debug_level.144;
  _Bool D.19535;
  long int D.19536;
  long int D.19537;
  struct FILE * gc_debug_file.145;
  int slot.146;
  int obj.147;
  int D.19543;
  struct MonoClass * D.19544;
  const char * D.19545;
  const char * D.19546;
  char * ptr;
  struct MonoVTable * vtable;

  ptr = *slot;
  D.19532 = MEM[(mword *)obj];
  D.19533 = D.19532 & 4294967292;
  vtable = (struct MonoVTable *) D.19533;
  gc_debug_level.144 = gc_debug_level;
  D.19535 = gc_debug_level.144 >= 0;
  D.19536 = (long int) D.19535;
  D.19537 = __builtin_expect (D.19536, 0);
  if (D.19537 != 0) goto <D.19538>; else goto <D.19539>;
  <D.19538>:
  gc_debug_file.145 = gc_debug_file;
  slot.146 = (int) slot;
  obj.147 = (int) obj;
  D.19543 = slot.146 - obj.147;
  D.19544 = vtable->klass;
  D.19545 = D.19544->name_space;
  D.19544 = vtable->klass;
  D.19546 = D.19544->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.19543, obj, D.19545, D.19546);
  gc_debug_file.145 = gc_debug_file;
  fflush (gc_debug_file.145);
  <D.19539>:
  broken_heap = 1;
}


sgen_check_objref (char * obj)
{
  int D.19547;
  _Bool D.19548;
  long int D.19549;
  long int D.19550;

  D.19547 = ptr_in_heap (obj);
  D.19548 = D.19547 == 0;
  D.19549 = (long int) D.19548;
  D.19550 = __builtin_expect (D.19549, 0);
  if (D.19550 != 0) goto <D.19551>; else goto <D.19552>;
  <D.19551>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 469, "ptr_in_heap (obj)");
  <D.19552>:
}


ptr_in_heap (char * object)
{
  int D.19553;
  gboolean D.19556;
  int D.19557;
  gboolean (*<T2be4>) (char *) D.19560;
  int D.19561;

  D.19553 = sgen_ptr_in_nursery (object);
  if (D.19553 != 0) goto <D.19554>; else goto <D.19555>;
  <D.19554>:
  D.19556 = 1;
  return D.19556;
  <D.19555>:
  D.19557 = sgen_los_is_valid_object (object);
  if (D.19557 != 0) goto <D.19558>; else goto <D.19559>;
  <D.19558>:
  D.19556 = 1;
  return D.19556;
  <D.19559>:
  D.19560 = major_collector.is_valid_object;
  D.19561 = D.19560 (object);
  if (D.19561 != 0) goto <D.19562>; else goto <D.19563>;
  <D.19562>:
  D.19556 = 1;
  return D.19556;
  <D.19563>:
  D.19556 = 0;
  return D.19556;
}


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

  setup_valid_nursery_objects ();
  D.19565 = major_collector.iterate_objects;
  D.19565 (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.19568;
  gboolean (*<T2be4>) (char *) D.19572;
  int D.19573;
  unsigned int D.19576;
  unsigned int D.19577;
  unsigned int D.19578;
  unsigned int D.19579;
  unsigned int D.19582;
  unsigned int D.19583;
  unsigned int D.19584;
  unsigned int D.19585;
  unsigned int D.19586;
  int D.19589;
  _Bool D.19590;
  long int D.19591;
  long int D.19592;
  int D.19595;
  unsigned int D.19598;
  unsigned int D.19599;
  _Bool D.19600;
  long int D.19601;
  long int D.19602;
  int D.19606;
  int D.19609;
  _Bool D.19610;
  long int D.19611;
  long int D.19612;
  gboolean (*<T2be4>) (char *) D.19616;
  int D.19617;
  int D.19620;
  _Bool D.19621;
  long int D.19622;
  long int D.19623;
  int D.19629;
  _Bool D.19630;
  long int D.19631;
  long int D.19632;
  int D.19635;
  unsigned int D.19638;
  unsigned int D.19639;
  _Bool D.19640;
  long int D.19641;
  long int D.19642;
  int D.19646;
  int D.19649;
  _Bool D.19650;
  long int D.19651;
  long int D.19652;
  int D.19656;
  int D.19659;
  _Bool D.19660;
  long int D.19661;
  long int D.19662;
  unsigned int _index.148;
  unsigned int D.19667;
  int D.19668;
  int D.19671;
  _Bool D.19672;
  long int D.19673;
  long int D.19674;
  int D.19677;
  unsigned int D.19680;
  unsigned int D.19681;
  _Bool D.19682;
  long int D.19683;
  long int D.19684;
  int D.19688;
  int D.19691;
  _Bool D.19692;
  long int D.19693;
  long int D.19694;
  int D.19698;
  int D.19701;
  _Bool D.19702;
  long int D.19703;
  long int D.19704;
  unsigned int _index.149;
  unsigned int D.19709;
  int D.19710;
  int D.19713;
  _Bool D.19714;
  long int D.19715;
  long int D.19716;
  int D.19719;
  unsigned int D.19722;
  unsigned int D.19723;
  _Bool D.19724;
  long int D.19725;
  long int D.19726;
  int D.19730;
  int D.19733;
  _Bool D.19734;
  long int D.19735;
  long int D.19736;
  int D.19740;
  int D.19743;
  _Bool D.19744;
  long int D.19745;
  long int D.19746;
  unsigned int D.19750;
  unsigned int D.19753;
  int D.19754;
  int desc.150;
  unsigned int D.19758;
  unsigned int el_size.151;
  unsigned int D.19760;
  int D.19763;
  _Bool D.19764;
  long int D.19765;
  long int D.19766;
  int D.19769;
  unsigned int D.19772;
  unsigned int D.19773;
  _Bool D.19774;
  long int D.19775;
  long int D.19776;
  int D.19780;
  int D.19783;
  _Bool D.19784;
  long int D.19785;
  long int D.19786;
  int D.19790;
  int D.19793;
  _Bool D.19794;
  long int D.19795;
  long int D.19796;
  int D.19803;
  unsigned int offset.152;
  unsigned int D.19805;
  char * D.19806;
  sizetype i.153;
  int D.19810;
  _Bool D.19811;
  long int D.19812;
  long int D.19813;
  int D.19816;
  unsigned int D.19819;
  unsigned int D.19820;
  _Bool D.19821;
  long int D.19822;
  long int D.19823;
  int D.19827;
  int D.19830;
  _Bool D.19831;
  long int D.19832;
  long int D.19833;
  int D.19837;
  int D.19840;
  _Bool D.19841;
  long int D.19842;
  long int D.19843;
  sizetype el_size.154;
  unsigned int D.19851;
  int D.19856;
  _Bool D.19857;
  long int D.19858;
  long int D.19859;
  int D.19862;
  unsigned int D.19865;
  unsigned int D.19866;
  _Bool D.19867;
  long int D.19868;
  long int D.19869;
  int D.19873;
  int D.19876;
  _Bool D.19877;
  long int D.19878;
  long int D.19879;
  int D.19883;
  int D.19886;
  _Bool D.19887;
  long int D.19888;
  long int D.19889;
  unsigned int D.19893;
  int D.19898;
  _Bool D.19899;
  long int D.19900;
  long int D.19901;
  int D.19904;
  unsigned int D.19907;
  unsigned int D.19908;
  _Bool D.19909;
  long int D.19910;
  long int D.19911;
  int D.19915;
  int D.19918;
  _Bool D.19919;
  long int D.19920;
  long int D.19921;
  int D.19925;
  int D.19928;
  _Bool D.19929;
  long int D.19930;
  long int D.19931;
  unsigned int D.19935;
  unsigned int D.19936;
  struct MonoVTable * D.19939;
  struct MonoClass * D.19940;
  const char * D.19941;
  const char * D.19942;
  gsize * bitmap_data.155;
  unsigned int D.19944;
  int D.19949;
  _Bool D.19950;
  long int D.19951;
  long int D.19952;
  int D.19955;
  unsigned int D.19958;
  unsigned int D.19959;
  _Bool D.19960;
  long int D.19961;
  long int D.19962;
  int D.19966;
  int D.19969;
  _Bool D.19970;
  long int D.19971;
  long int D.19972;
  int D.19976;
  int D.19979;
  _Bool D.19980;
  long int D.19981;
  long int D.19982;
  int bwords.156;
  unsigned int D.19987;
  gsize * mbitmap_data.157;
  unsigned int D.19989;
  unsigned int D.19990;
  struct MonoClass * D.19991;
  unsigned int el_size.158;
  unsigned int D.19993;
  const char * D.19996;
  const char * D.19997;
  gsize * bitmap_data.159;
  unsigned int D.19999;
  int D.20004;
  _Bool D.20005;
  long int D.20006;
  long int D.20007;
  int D.20010;
  unsigned int D.20013;
  unsigned int D.20014;
  _Bool D.20015;
  long int D.20016;
  long int D.20017;
  int D.20021;
  int D.20024;
  _Bool D.20025;
  long int D.20026;
  long int D.20027;
  int D.20031;
  int D.20034;
  _Bool D.20035;
  long int D.20036;
  long int D.20037;
  unsigned int bwords.160;
  sizetype el_size.161;
  gboolean is_los;

  is_los = (gboolean) dummy;
  if (is_los != 0) goto <D.19566>; else goto <D.19567>;
  <D.19566>:
  D.19568 = sgen_los_object_is_pinned (start);
  if (D.19568 == 0) goto <D.19569>; else goto <D.19570>;
  <D.19569>:
  return;
  <D.19570>:
  goto <D.19571>;
  <D.19567>:
  D.19572 = major_collector.is_object_live;
  D.19573 = D.19572 (start);
  if (D.19573 == 0) goto <D.19574>; else goto <D.19575>;
  <D.19574>:
  return;
  <D.19575>:
  <D.19571>:
  {
    struct GCVTable * vt;
    mword desc;

    D.19576 = MEM[(mword *)start];
    D.19577 = D.19576 & 4294967292;
    vt = (struct GCVTable *) D.19577;
    desc = vt->desc;
    D.19578 = desc & 7;
    switch (D.19578) <default: <D.17997>, case 1: <D.17902>, case 2: <D.17911>, case 3: <D.17961>, case 4: <D.17921>, case 5: <D.17954>, case 6: <D.17975>, case 7: <D.17996>>
    <D.17902>:
    D.19579 = desc & 4294901760;
    if (D.19579 != 0) goto <D.19580>; else goto <D.19581>;
    <D.19580>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19582 = desc >> 16;
      D.19583 = D.19582 & 255;
      D.19584 = D.19583 * 4;
      _objptr = _objptr + D.19584;
      D.19585 = desc >> 24;
      D.19586 = D.19585 * 4;
      _objptr_end = _objptr + D.19586;
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.19587>; else goto <D.19588>;
        <D.19587>:
        D.19589 = is_valid_object_pointer (__target);
        D.19590 = D.19589 == 0;
        D.19591 = (long int) D.19590;
        D.19592 = __builtin_expect (D.19591, 0);
        if (D.19592 != 0) goto <D.19593>; else goto <D.19594>;
        <D.19593>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "is_valid_object_pointer (__target)");
        <D.19594>:
        D.19595 = sgen_ptr_in_nursery (__target);
        if (D.19595 != 0) goto <D.19596>; else goto <D.19597>;
        <D.19596>:
        D.19598 = MEM[(mword *)__target];
        D.19599 = D.19598 & 2;
        D.19600 = D.19599 == 0;
        D.19601 = (long int) D.19600;
        D.19602 = __builtin_expect (D.19601, 0);
        if (D.19602 != 0) goto <D.19603>; else goto <D.19604>;
        <D.19603>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.19604>:
        goto <D.19605>;
        <D.19597>:
        D.19606 = sgen_los_is_valid_object (__target);
        if (D.19606 != 0) goto <D.19607>; else goto <D.19608>;
        <D.19607>:
        D.19609 = sgen_los_object_is_pinned (__target);
        D.19610 = D.19609 == 0;
        D.19611 = (long int) D.19610;
        D.19612 = __builtin_expect (D.19611, 0);
        if (D.19612 != 0) goto <D.19613>; else goto <D.19614>;
        <D.19613>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_los_object_is_pinned (__target)");
        <D.19614>:
        goto <D.19615>;
        <D.19608>:
        D.19616 = major_collector.is_valid_object;
        D.19617 = D.19616 (__target);
        if (D.19617 != 0) goto <D.19618>; else goto <D.19619>;
        <D.19618>:
        D.19572 = major_collector.is_object_live;
        D.19620 = D.19572 (__target);
        D.19621 = D.19620 == 0;
        D.19622 = (long int) D.19621;
        D.19623 = __builtin_expect (D.19622, 0);
        if (D.19623 != 0) goto <D.19624>; else goto <D.19625>;
        <D.19624>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "major_collector.is_object_live (__target)");
        <D.19625>:
        goto <D.19626>;
        <D.19619>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 64);
        <D.19626>:
        <D.19615>:
        <D.19605>:
        <D.19588>:
      }
      _objptr = _objptr + 4;
      goto <D.17908>;
      <D.17907>:
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.19627>; else goto <D.19628>;
        <D.19627>:
        D.19629 = is_valid_object_pointer (__target);
        D.19630 = D.19629 == 0;
        D.19631 = (long int) D.19630;
        D.19632 = __builtin_expect (D.19631, 0);
        if (D.19632 != 0) goto <D.19633>; else goto <D.19634>;
        <D.19633>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "is_valid_object_pointer (__target)");
        <D.19634>:
        D.19635 = sgen_ptr_in_nursery (__target);
        if (D.19635 != 0) goto <D.19636>; else goto <D.19637>;
        <D.19636>:
        D.19638 = MEM[(mword *)__target];
        D.19639 = D.19638 & 2;
        D.19640 = D.19639 == 0;
        D.19641 = (long int) D.19640;
        D.19642 = __builtin_expect (D.19641, 0);
        if (D.19642 != 0) goto <D.19643>; else goto <D.19644>;
        <D.19643>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.19644>:
        goto <D.19645>;
        <D.19637>:
        D.19646 = sgen_los_is_valid_object (__target);
        if (D.19646 != 0) goto <D.19647>; else goto <D.19648>;
        <D.19647>:
        D.19649 = sgen_los_object_is_pinned (__target);
        D.19650 = D.19649 == 0;
        D.19651 = (long int) D.19650;
        D.19652 = __builtin_expect (D.19651, 0);
        if (D.19652 != 0) goto <D.19653>; else goto <D.19654>;
        <D.19653>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_los_object_is_pinned (__target)");
        <D.19654>:
        goto <D.19655>;
        <D.19648>:
        D.19616 = major_collector.is_valid_object;
        D.19656 = D.19616 (__target);
        if (D.19656 != 0) goto <D.19657>; else goto <D.19658>;
        <D.19657>:
        D.19572 = major_collector.is_object_live;
        D.19659 = D.19572 (__target);
        D.19660 = D.19659 == 0;
        D.19661 = (long int) D.19660;
        D.19662 = __builtin_expect (D.19661, 0);
        if (D.19662 != 0) goto <D.19663>; else goto <D.19664>;
        <D.19663>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "major_collector.is_object_live (__target)");
        <D.19664>:
        goto <D.19665>;
        <D.19658>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 64);
        <D.19665>:
        <D.19655>:
        <D.19645>:
        <D.19628>:
      }
      _objptr = _objptr + 4;
      <D.17908>:
      if (_objptr < _objptr_end) goto <D.17907>; else goto <D.17909>;
      <D.17909>:
    }
    <D.19581>:
    goto <D.17910>;
    <D.17911>:
    {
      void * * _objptr;
      gsize _bmap;

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

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

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.19669>; else goto <D.19670>;
          <D.19669>:
          D.19671 = is_valid_object_pointer (__target);
          D.19672 = D.19671 == 0;
          D.19673 = (long int) D.19672;
          D.19674 = __builtin_expect (D.19673, 0);
          if (D.19674 != 0) goto <D.19675>; else goto <D.19676>;
          <D.19675>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "is_valid_object_pointer (__target)");
          <D.19676>:
          D.19677 = sgen_ptr_in_nursery (__target);
          if (D.19677 != 0) goto <D.19678>; else goto <D.19679>;
          <D.19678>:
          D.19680 = MEM[(mword *)__target];
          D.19681 = D.19680 & 2;
          D.19682 = D.19681 == 0;
          D.19683 = (long int) D.19682;
          D.19684 = __builtin_expect (D.19683, 0);
          if (D.19684 != 0) goto <D.19685>; else goto <D.19686>;
          <D.19685>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.19686>:
          goto <D.19687>;
          <D.19679>:
          D.19688 = sgen_los_is_valid_object (__target);
          if (D.19688 != 0) goto <D.19689>; else goto <D.19690>;
          <D.19689>:
          D.19691 = sgen_los_object_is_pinned (__target);
          D.19692 = D.19691 == 0;
          D.19693 = (long int) D.19692;
          D.19694 = __builtin_expect (D.19693, 0);
          if (D.19694 != 0) goto <D.19695>; else goto <D.19696>;
          <D.19695>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_los_object_is_pinned (__target)");
          <D.19696>:
          goto <D.19697>;
          <D.19690>:
          D.19616 = major_collector.is_valid_object;
          D.19698 = D.19616 (__target);
          if (D.19698 != 0) goto <D.19699>; else goto <D.19700>;
          <D.19699>:
          D.19572 = major_collector.is_object_live;
          D.19701 = D.19572 (__target);
          D.19702 = D.19701 == 0;
          D.19703 = (long int) D.19702;
          D.19704 = __builtin_expect (D.19703, 0);
          if (D.19704 != 0) goto <D.19705>; else goto <D.19706>;
          <D.19705>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "major_collector.is_object_live (__target)");
          <D.19706>:
          goto <D.19707>;
          <D.19700>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 71);
          <D.19707>:
          <D.19697>:
          <D.19687>:
          <D.19670>:
        }
        _objptr = _objptr + 4;
      }
      goto <D.17919>;
      <D.17918>:
      {
        int _index;

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

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.19711>; else goto <D.19712>;
          <D.19711>:
          D.19713 = is_valid_object_pointer (__target);
          D.19714 = D.19713 == 0;
          D.19715 = (long int) D.19714;
          D.19716 = __builtin_expect (D.19715, 0);
          if (D.19716 != 0) goto <D.19717>; else goto <D.19718>;
          <D.19717>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "is_valid_object_pointer (__target)");
          <D.19718>:
          D.19719 = sgen_ptr_in_nursery (__target);
          if (D.19719 != 0) goto <D.19720>; else goto <D.19721>;
          <D.19720>:
          D.19722 = MEM[(mword *)__target];
          D.19723 = D.19722 & 2;
          D.19724 = D.19723 == 0;
          D.19725 = (long int) D.19724;
          D.19726 = __builtin_expect (D.19725, 0);
          if (D.19726 != 0) goto <D.19727>; else goto <D.19728>;
          <D.19727>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.19728>:
          goto <D.19729>;
          <D.19721>:
          D.19730 = sgen_los_is_valid_object (__target);
          if (D.19730 != 0) goto <D.19731>; else goto <D.19732>;
          <D.19731>:
          D.19733 = sgen_los_object_is_pinned (__target);
          D.19734 = D.19733 == 0;
          D.19735 = (long int) D.19734;
          D.19736 = __builtin_expect (D.19735, 0);
          if (D.19736 != 0) goto <D.19737>; else goto <D.19738>;
          <D.19737>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_los_object_is_pinned (__target)");
          <D.19738>:
          goto <D.19739>;
          <D.19732>:
          D.19616 = major_collector.is_valid_object;
          D.19740 = D.19616 (__target);
          if (D.19740 != 0) goto <D.19741>; else goto <D.19742>;
          <D.19741>:
          D.19572 = major_collector.is_object_live;
          D.19743 = D.19572 (__target);
          D.19744 = D.19743 == 0;
          D.19745 = (long int) D.19744;
          D.19746 = __builtin_expect (D.19745, 0);
          if (D.19746 != 0) goto <D.19747>; else goto <D.19748>;
          <D.19747>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "major_collector.is_object_live (__target)");
          <D.19748>:
          goto <D.19749>;
          <D.19742>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 71);
          <D.19749>:
          <D.19739>:
          <D.19729>:
          <D.19712>:
        }
        _objptr = _objptr + 4;
      }
      <D.17919>:
      if (_bmap != 0) goto <D.17918>; else goto <D.17920>;
      <D.17920>:
    }
    goto <D.17910>;
    <D.17921>:
    D.19750 = desc & 4294950912;
    if (D.19750 != 0) goto <D.19751>; else goto <D.19752>;
    <D.19751>:
    {
      int el_size;
      int etype;

      D.19753 = desc >> 3;
      D.19754 = (int) D.19753;
      el_size = D.19754 & 1023;
      desc.150 = (int) desc;
      etype = desc.150 & 49152;
      if (etype == 16384) goto <D.19756>; else goto <D.19757>;
      <D.19756>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.19758 = MEM[(struct MonoArray *)start].max_length;
        el_size.151 = (unsigned int) el_size;
        D.19760 = D.19758 * el_size.151;
        end_refs = p + D.19760;
        goto <D.17928>;
        <D.17927>:
        {
          char * __target;

          __target = MEM[(char * *)p];
          if (__target != 0B) goto <D.19761>; else goto <D.19762>;
          <D.19761>:
          D.19763 = is_valid_object_pointer (__target);
          D.19764 = D.19763 == 0;
          D.19765 = (long int) D.19764;
          D.19766 = __builtin_expect (D.19765, 0);
          if (D.19766 != 0) goto <D.19767>; else goto <D.19768>;
          <D.19767>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "is_valid_object_pointer (__target)");
          <D.19768>:
          D.19769 = sgen_ptr_in_nursery (__target);
          if (D.19769 != 0) goto <D.19770>; else goto <D.19771>;
          <D.19770>:
          D.19772 = MEM[(mword *)__target];
          D.19773 = D.19772 & 2;
          D.19774 = D.19773 == 0;
          D.19775 = (long int) D.19774;
          D.19776 = __builtin_expect (D.19775, 0);
          if (D.19776 != 0) goto <D.19777>; else goto <D.19778>;
          <D.19777>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.19778>:
          goto <D.19779>;
          <D.19771>:
          D.19780 = sgen_los_is_valid_object (__target);
          if (D.19780 != 0) goto <D.19781>; else goto <D.19782>;
          <D.19781>:
          D.19783 = sgen_los_object_is_pinned (__target);
          D.19784 = D.19783 == 0;
          D.19785 = (long int) D.19784;
          D.19786 = __builtin_expect (D.19785, 0);
          if (D.19786 != 0) goto <D.19787>; else goto <D.19788>;
          <D.19787>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
          <D.19788>:
          goto <D.19789>;
          <D.19782>:
          D.19616 = major_collector.is_valid_object;
          D.19790 = D.19616 (__target);
          if (D.19790 != 0) goto <D.19791>; else goto <D.19792>;
          <D.19791>:
          D.19572 = major_collector.is_object_live;
          D.19793 = D.19572 (__target);
          D.19794 = D.19793 == 0;
          D.19795 = (long int) D.19794;
          D.19796 = __builtin_expect (D.19795, 0);
          if (D.19796 != 0) goto <D.19797>; else goto <D.19798>;
          <D.19797>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
          <D.19798>:
          goto <D.19799>;
          <D.19792>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
          <D.19799>:
          <D.19789>:
          <D.19779>:
          <D.19762>:
        }
        p = p + 4;
        <D.17928>:
        if (p < end_refs) goto <D.17927>; else goto <D.17929>;
        <D.17929>:
      }
      goto <D.19800>;
      <D.19757>:
      if (etype == 32768) goto <D.19801>; else goto <D.19802>;
      <D.19801>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19582 = desc >> 16;
        D.19803 = (int) D.19582;
        offset = D.19803 & 255;
        D.19585 = desc >> 24;
        num_refs = (int) D.19585;
        e_start = start + 16;
        D.19758 = MEM[(struct MonoArray *)start].max_length;
        el_size.151 = (unsigned int) el_size;
        D.19760 = D.19758 * el_size.151;
        e_end = e_start + D.19760;
        goto <D.17941>;
        <D.17940>:
        {
          void * * p;
          int i;

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

            D.19806 = MEM[(char * *)p];
            i.153 = (sizetype) i;
            __target = D.19806 + i.153;
            if (__target != 0B) goto <D.19808>; else goto <D.19809>;
            <D.19808>:
            D.19810 = is_valid_object_pointer (__target);
            D.19811 = D.19810 == 0;
            D.19812 = (long int) D.19811;
            D.19813 = __builtin_expect (D.19812, 0);
            if (D.19813 != 0) goto <D.19814>; else goto <D.19815>;
            <D.19814>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "is_valid_object_pointer (__target)");
            <D.19815>:
            D.19816 = sgen_ptr_in_nursery (__target);
            if (D.19816 != 0) goto <D.19817>; else goto <D.19818>;
            <D.19817>:
            D.19819 = MEM[(mword *)__target];
            D.19820 = D.19819 & 2;
            D.19821 = D.19820 == 0;
            D.19822 = (long int) D.19821;
            D.19823 = __builtin_expect (D.19822, 0);
            if (D.19823 != 0) goto <D.19824>; else goto <D.19825>;
            <D.19824>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.19825>:
            goto <D.19826>;
            <D.19818>:
            D.19827 = sgen_los_is_valid_object (__target);
            if (D.19827 != 0) goto <D.19828>; else goto <D.19829>;
            <D.19828>:
            D.19830 = sgen_los_object_is_pinned (__target);
            D.19831 = D.19830 == 0;
            D.19832 = (long int) D.19831;
            D.19833 = __builtin_expect (D.19832, 0);
            if (D.19833 != 0) goto <D.19834>; else goto <D.19835>;
            <D.19834>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
            <D.19835>:
            goto <D.19836>;
            <D.19829>:
            D.19616 = major_collector.is_valid_object;
            D.19837 = D.19616 (__target);
            if (D.19837 != 0) goto <D.19838>; else goto <D.19839>;
            <D.19838>:
            D.19572 = major_collector.is_object_live;
            D.19840 = D.19572 (__target);
            D.19841 = D.19840 == 0;
            D.19842 = (long int) D.19841;
            D.19843 = __builtin_expect (D.19842, 0);
            if (D.19843 != 0) goto <D.19844>; else goto <D.19845>;
            <D.19844>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
            <D.19845>:
            goto <D.19846>;
            <D.19839>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
            <D.19846>:
            <D.19836>:
            <D.19826>:
            <D.19809>:
          }
          i = i + 1;
          <D.17938>:
          if (i < num_refs) goto <D.17937>; else goto <D.17939>;
          <D.17939>:
          el_size.154 = (sizetype) el_size;
          e_start = e_start + el_size.154;
        }
        <D.17941>:
        if (e_start < e_end) goto <D.17940>; else goto <D.17942>;
        <D.17942>:
      }
      goto <D.19848>;
      <D.19802>:
      if (etype == 49152) goto <D.19849>; else goto <D.19850>;
      <D.19849>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.19758 = MEM[(struct MonoArray *)start].max_length;
        el_size.151 = (unsigned int) el_size;
        D.19760 = D.19758 * el_size.151;
        e_end = e_start + D.19760;
        goto <D.17952>;
        <D.17951>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17949>;
          <D.17948>:
          D.19851 = _bmap & 1;
          if (D.19851 != 0) goto <D.19852>; else goto <D.19853>;
          <D.19852>:
          {
            char * __target;

            __target = MEM[(char * *)p];
            if (__target != 0B) goto <D.19854>; else goto <D.19855>;
            <D.19854>:
            D.19856 = is_valid_object_pointer (__target);
            D.19857 = D.19856 == 0;
            D.19858 = (long int) D.19857;
            D.19859 = __builtin_expect (D.19858, 0);
            if (D.19859 != 0) goto <D.19860>; else goto <D.19861>;
            <D.19860>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "is_valid_object_pointer (__target)");
            <D.19861>:
            D.19862 = sgen_ptr_in_nursery (__target);
            if (D.19862 != 0) goto <D.19863>; else goto <D.19864>;
            <D.19863>:
            D.19865 = MEM[(mword *)__target];
            D.19866 = D.19865 & 2;
            D.19867 = D.19866 == 0;
            D.19868 = (long int) D.19867;
            D.19869 = __builtin_expect (D.19868, 0);
            if (D.19869 != 0) goto <D.19870>; else goto <D.19871>;
            <D.19870>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.19871>:
            goto <D.19872>;
            <D.19864>:
            D.19873 = sgen_los_is_valid_object (__target);
            if (D.19873 != 0) goto <D.19874>; else goto <D.19875>;
            <D.19874>:
            D.19876 = sgen_los_object_is_pinned (__target);
            D.19877 = D.19876 == 0;
            D.19878 = (long int) D.19877;
            D.19879 = __builtin_expect (D.19878, 0);
            if (D.19879 != 0) goto <D.19880>; else goto <D.19881>;
            <D.19880>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
            <D.19881>:
            goto <D.19882>;
            <D.19875>:
            D.19616 = major_collector.is_valid_object;
            D.19883 = D.19616 (__target);
            if (D.19883 != 0) goto <D.19884>; else goto <D.19885>;
            <D.19884>:
            D.19572 = major_collector.is_object_live;
            D.19886 = D.19572 (__target);
            D.19887 = D.19886 == 0;
            D.19888 = (long int) D.19887;
            D.19889 = __builtin_expect (D.19888, 0);
            if (D.19889 != 0) goto <D.19890>; else goto <D.19891>;
            <D.19890>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
            <D.19891>:
            goto <D.19892>;
            <D.19885>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
            <D.19892>:
            <D.19882>:
            <D.19872>:
            <D.19855>:
          }
          <D.19853>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17949>:
          if (_bmap != 0) goto <D.17948>; else goto <D.17950>;
          <D.17950>:
          el_size.154 = (sizetype) el_size;
          e_start = e_start + el_size.154;
        }
        <D.17952>:
        if (e_start < e_end) goto <D.17951>; else goto <D.17953>;
        <D.17953>:
      }
      <D.19850>:
      <D.19848>:
      <D.19800>:
    }
    <D.19752>:
    goto <D.17910>;
    <D.17954>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17959>;
      <D.17958>:
      D.19893 = _bmap & 1;
      if (D.19893 != 0) goto <D.19894>; else goto <D.19895>;
      <D.19894>:
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.19896>; else goto <D.19897>;
        <D.19896>:
        D.19898 = is_valid_object_pointer (__target);
        D.19899 = D.19898 == 0;
        D.19900 = (long int) D.19899;
        D.19901 = __builtin_expect (D.19900, 0);
        if (D.19901 != 0) goto <D.19902>; else goto <D.19903>;
        <D.19902>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "is_valid_object_pointer (__target)");
        <D.19903>:
        D.19904 = sgen_ptr_in_nursery (__target);
        if (D.19904 != 0) goto <D.19905>; else goto <D.19906>;
        <D.19905>:
        D.19907 = MEM[(mword *)__target];
        D.19908 = D.19907 & 2;
        D.19909 = D.19908 == 0;
        D.19910 = (long int) D.19909;
        D.19911 = __builtin_expect (D.19910, 0);
        if (D.19911 != 0) goto <D.19912>; else goto <D.19913>;
        <D.19912>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.19913>:
        goto <D.19914>;
        <D.19906>:
        D.19915 = sgen_los_is_valid_object (__target);
        if (D.19915 != 0) goto <D.19916>; else goto <D.19917>;
        <D.19916>:
        D.19918 = sgen_los_object_is_pinned (__target);
        D.19919 = D.19918 == 0;
        D.19920 = (long int) D.19919;
        D.19921 = __builtin_expect (D.19920, 0);
        if (D.19921 != 0) goto <D.19922>; else goto <D.19923>;
        <D.19922>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "sgen_los_object_is_pinned (__target)");
        <D.19923>:
        goto <D.19924>;
        <D.19917>:
        D.19616 = major_collector.is_valid_object;
        D.19925 = D.19616 (__target);
        if (D.19925 != 0) goto <D.19926>; else goto <D.19927>;
        <D.19926>:
        D.19572 = major_collector.is_object_live;
        D.19928 = D.19572 (__target);
        D.19929 = D.19928 == 0;
        D.19930 = (long int) D.19929;
        D.19931 = __builtin_expect (D.19930, 0);
        if (D.19931 != 0) goto <D.19932>; else goto <D.19933>;
        <D.19932>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "major_collector.is_object_live (__target)");
        <D.19933>:
        goto <D.19934>;
        <D.19927>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 85);
        <D.19934>:
        <D.19924>:
        <D.19914>:
        <D.19897>:
      }
      <D.19895>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17959>:
      if (_bmap != 0) goto <D.17958>; else goto <D.17960>;
      <D.17960>:
    }
    goto <D.17910>;
    <D.17961>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19935 = *bitmap_data;
      D.19936 = D.19935 + 4294967295;
      bwords = (int) D.19936;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.19937>; else goto <D.19938>;
      <D.19937>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19939 = myobj->vtable;
        D.19940 = D.19939->klass;
        D.19941 = D.19940->name_space;
        D.19939 = myobj->vtable;
        D.19940 = D.19939->klass;
        D.19942 = D.19940->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19941, D.19942);
      }
      <D.19938>:
      goto <D.17973>;
      <D.17972>:
      {
        gsize _bmap;

        bitmap_data.155 = bitmap_data;
        bitmap_data = bitmap_data.155 + 4;
        _bmap = *bitmap_data.155;
        _objptr = start_run;
        goto <D.17970>;
        <D.17969>:
        D.19944 = _bmap & 1;
        if (D.19944 != 0) goto <D.19945>; else goto <D.19946>;
        <D.19945>:
        {
          char * __target;

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.19947>; else goto <D.19948>;
          <D.19947>:
          D.19949 = is_valid_object_pointer (__target);
          D.19950 = D.19949 == 0;
          D.19951 = (long int) D.19950;
          D.19952 = __builtin_expect (D.19951, 0);
          if (D.19952 != 0) goto <D.19953>; else goto <D.19954>;
          <D.19953>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "is_valid_object_pointer (__target)");
          <D.19954>:
          D.19955 = sgen_ptr_in_nursery (__target);
          if (D.19955 != 0) goto <D.19956>; else goto <D.19957>;
          <D.19956>:
          D.19958 = MEM[(mword *)__target];
          D.19959 = D.19958 & 2;
          D.19960 = D.19959 == 0;
          D.19961 = (long int) D.19960;
          D.19962 = __builtin_expect (D.19961, 0);
          if (D.19962 != 0) goto <D.19963>; else goto <D.19964>;
          <D.19963>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.19964>:
          goto <D.19965>;
          <D.19957>:
          D.19966 = sgen_los_is_valid_object (__target);
          if (D.19966 != 0) goto <D.19967>; else goto <D.19968>;
          <D.19967>:
          D.19969 = sgen_los_object_is_pinned (__target);
          D.19970 = D.19969 == 0;
          D.19971 = (long int) D.19970;
          D.19972 = __builtin_expect (D.19971, 0);
          if (D.19972 != 0) goto <D.19973>; else goto <D.19974>;
          <D.19973>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "sgen_los_object_is_pinned (__target)");
          <D.19974>:
          goto <D.19975>;
          <D.19968>:
          D.19616 = major_collector.is_valid_object;
          D.19976 = D.19616 (__target);
          if (D.19976 != 0) goto <D.19977>; else goto <D.19978>;
          <D.19977>:
          D.19572 = major_collector.is_object_live;
          D.19979 = D.19572 (__target);
          D.19980 = D.19979 == 0;
          D.19981 = (long int) D.19980;
          D.19982 = __builtin_expect (D.19981, 0);
          if (D.19982 != 0) goto <D.19983>; else goto <D.19984>;
          <D.19983>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "major_collector.is_object_live (__target)");
          <D.19984>:
          goto <D.19985>;
          <D.19978>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 93);
          <D.19985>:
          <D.19975>:
          <D.19965>:
          <D.19948>:
        }
        <D.19946>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17970>:
        if (_bmap != 0) goto <D.17969>; else goto <D.17971>;
        <D.17971>:
        start_run = start_run + 128;
      }
      <D.17973>:
      bwords.156 = bwords;
      bwords = bwords.156 + -1;
      if (bwords.156 > 0) goto <D.17972>; else goto <D.17974>;
      <D.17974>:
    }
    goto <D.17910>;
    <D.17975>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19987 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19987);
      mbitmap_data.157 = mbitmap_data;
      mbitmap_data = mbitmap_data.157 + 4;
      D.19989 = *mbitmap_data.157;
      D.19990 = D.19989 + 4294967295;
      mbwords = (int) D.19990;
      D.19991 = vt->klass;
      el_size = mono_array_element_size (D.19991);
      e_start = start + 16;
      D.19758 = MEM[(struct MonoArray *)start].max_length;
      el_size.158 = (unsigned int) el_size;
      D.19993 = D.19758 * el_size.158;
      e_end = e_start + D.19993;
      if (0 != 0) goto <D.19994>; else goto <D.19995>;
      <D.19994>:
      D.19987 = vt->desc;
      D.19991 = vt->klass;
      D.19996 = D.19991->name_space;
      D.19991 = vt->klass;
      D.19997 = D.19991->name;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19987, D.19996, D.19997);
      <D.19995>:
      goto <D.17994>;
      <D.17993>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.17991>;
        <D.17990>:
        {
          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.17988>;
          <D.17987>:
          D.19999 = _bmap & 1;
          if (D.19999 != 0) goto <D.20000>; else goto <D.20001>;
          <D.20000>:
          {
            char * __target;

            __target = MEM[(char * *)_objptr];
            if (__target != 0B) goto <D.20002>; else goto <D.20003>;
            <D.20002>:
            D.20004 = is_valid_object_pointer (__target);
            D.20005 = D.20004 == 0;
            D.20006 = (long int) D.20005;
            D.20007 = __builtin_expect (D.20006, 0);
            if (D.20007 != 0) goto <D.20008>; else goto <D.20009>;
            <D.20008>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "is_valid_object_pointer (__target)");
            <D.20009>:
            D.20010 = sgen_ptr_in_nursery (__target);
            if (D.20010 != 0) goto <D.20011>; else goto <D.20012>;
            <D.20011>:
            D.20013 = MEM[(mword *)__target];
            D.20014 = D.20013 & 2;
            D.20015 = D.20014 == 0;
            D.20016 = (long int) D.20015;
            D.20017 = __builtin_expect (D.20016, 0);
            if (D.20017 != 0) goto <D.20018>; else goto <D.20019>;
            <D.20018>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.20019>:
            goto <D.20020>;
            <D.20012>:
            D.20021 = sgen_los_is_valid_object (__target);
            if (D.20021 != 0) goto <D.20022>; else goto <D.20023>;
            <D.20022>:
            D.20024 = sgen_los_object_is_pinned (__target);
            D.20025 = D.20024 == 0;
            D.20026 = (long int) D.20025;
            D.20027 = __builtin_expect (D.20026, 0);
            if (D.20027 != 0) goto <D.20028>; else goto <D.20029>;
            <D.20028>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "sgen_los_object_is_pinned (__target)");
            <D.20029>:
            goto <D.20030>;
            <D.20023>:
            D.19616 = major_collector.is_valid_object;
            D.20031 = D.19616 (__target);
            if (D.20031 != 0) goto <D.20032>; else goto <D.20033>;
            <D.20032>:
            D.19572 = major_collector.is_object_live;
            D.20034 = D.19572 (__target);
            D.20035 = D.20034 == 0;
            D.20036 = (long int) D.20035;
            D.20037 = __builtin_expect (D.20036, 0);
            if (D.20037 != 0) goto <D.20038>; else goto <D.20039>;
            <D.20038>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "major_collector.is_object_live (__target)");
            <D.20039>:
            goto <D.20040>;
            <D.20033>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 102);
            <D.20040>:
            <D.20030>:
            <D.20020>:
            <D.20003>:
          }
          <D.20001>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17988>:
          if (_bmap != 0) goto <D.17987>; else goto <D.17989>;
          <D.17989>:
          _objptr = start_run + 128;
        }
        <D.17991>:
        bwords.160 = bwords;
        bwords = bwords.160 + 4294967295;
        if (bwords.160 != 0) goto <D.17990>; else goto <D.17992>;
        <D.17992>:
        el_size.161 = (sizetype) el_size;
        e_start = e_start + el_size.161;
      }
      <D.17994>:
      if (e_start < e_end) goto <D.17993>; else goto <D.17995>;
      <D.17995>:
    }
    goto <D.17910>;
    <D.17996>:
    goto <D.17910>;
    <D.17997>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17910>:
  }
}


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

  sgen_clear_nursery_fragments ();
  nursery_section.162 = nursery_section;
  D.20046 = nursery_section.162->data;
  nursery_section.162 = nursery_section;
  D.20047 = nursery_section.162->end_data;
  pinned.163 = (void *) pinned;
  sgen_scan_area_with_callback (D.20046, D.20047, 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.20052;
  unsigned int D.20053;
  unsigned int D.20055;
  _Bool D.20057;
  long int D.20058;
  long int D.20059;
  unsigned int D.20064;
  _Bool D.20065;
  long int D.20066;
  long int D.20067;
  _Bool D.20071;
  long int D.20072;
  long int D.20073;
  gboolean pinned;

  pinned = (gboolean) data;
  D.20052 = MEM[(mword *)obj];
  D.20053 = D.20052 & 1;
  if (D.20053 != 0) goto <D.20054>; else goto <D.20050>;
  <D.20054>:
  D.20052 = MEM[(mword *)obj];
  D.20055 = D.20052 & 4294967292;
  if (D.20055 != 0) goto <D.20056>; else goto <D.20050>;
  <D.20056>:
  iftmp.164 = 1;
  goto <D.20051>;
  <D.20050>:
  iftmp.164 = 0;
  <D.20051>:
  D.20057 = iftmp.164 != 0;
  D.20058 = (long int) D.20057;
  D.20059 = __builtin_expect (D.20058, 0);
  if (D.20059 != 0) goto <D.20060>; else goto <D.20061>;
  <D.20060>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 575, "!SGEN_OBJECT_IS_FORWARDED (obj)");
  <D.20061>:
  if (pinned != 0) goto <D.20062>; else goto <D.20063>;
  <D.20062>:
  D.20052 = MEM[(mword *)obj];
  D.20064 = D.20052 & 2;
  D.20065 = D.20064 == 0;
  D.20066 = (long int) D.20065;
  D.20067 = __builtin_expect (D.20066, 0);
  if (D.20067 != 0) goto <D.20068>; else goto <D.20069>;
  <D.20068>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 577, "SGEN_OBJECT_IS_PINNED (obj)");
  <D.20069>:
  goto <D.20070>;
  <D.20063>:
  D.20052 = MEM[(mword *)obj];
  D.20064 = D.20052 & 2;
  D.20071 = D.20064 != 0;
  D.20072 = (long int) D.20071;
  D.20073 = __builtin_expect (D.20072, 0);
  if (D.20073 != 0) goto <D.20074>; else goto <D.20075>;
  <D.20074>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 579, "!SGEN_OBJECT_IS_PINNED (obj)");
  <D.20075>:
  <D.20070>:
}