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


describe_pointer (char * ptr, gboolean need_setup)
{
  int D.18031;
  char * start.0;
  char * start.1;
  unsigned int D.18038;
  unsigned int D.18039;
  int D.18041;
  int ptr.2;
  int start.3;
  int D.18049;
  gboolean (*<T2c69>) (char *, char * *) D.18051;
  int D.18052;
  struct MonoVTable * (*<T2c83>) (char *) D.18063;
  gboolean (*<T2bea>) (char *) D.18065;
  int D.18066;
  unsigned int D.18070;
  char * iftmp.4;
  unsigned int D.18074;
  int D.18082;
  struct MonoClass * D.18085;
  const char * D.18086;
  long int desc.5;
  int desc.6;
  const char * D.18089;
  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.18031 = sgen_ptr_in_nursery (ptr);
      if (D.18031 != 0) goto <D.18032>; else goto <D.18033>;
      <D.18032>:
      start.0 = describe_nursery_ptr (ptr, need_setup);
      start = start.0;
      start.1 = start;
      if (start.1 == 0B) goto <D.18036>; else goto <D.18037>;
      <D.18036>:
      return;
      <D.18037>:
      ptr = start;
      D.18038 = MEM[(mword *)ptr];
      D.18039 = D.18038 & 4294967292;
      vtable = (struct MonoVTable *) D.18039;
      goto <D.18040>;
      <D.18033>:
      D.18041 = sgen_ptr_is_in_los (ptr, &start);
      if (D.18041 != 0) goto <D.18042>; else goto <D.18043>;
      <D.18042>:
      start.1 = start;
      if (ptr == start.1) goto <D.18044>; else goto <D.18045>;
      <D.18044>:
      start.1 = start;
      printf ("Pointer is the start of object %p in LOS space.\n", start.1);
      goto <D.18046>;
      <D.18045>:
      start.1 = start;
      ptr.2 = (int) ptr;
      start.1 = start;
      start.3 = (int) start.1;
      D.18049 = ptr.2 - start.3;
      printf ("Pointer is at offset 0x%x of object %p in LOS space.\n", D.18049, start.1);
      <D.18046>:
      ptr = start;
      mono_sgen_los_describe_pointer (ptr);
      D.18038 = MEM[(mword *)ptr];
      D.18039 = D.18038 & 4294967292;
      vtable = (struct MonoVTable *) D.18039;
      goto <D.18050>;
      <D.18043>:
      D.18051 = major_collector.ptr_is_in_non_pinned_space;
      D.18052 = D.18051 (ptr, &start);
      if (D.18052 != 0) goto <D.18053>; else goto <D.18054>;
      <D.18053>:
      start.1 = start;
      if (ptr == start.1) goto <D.18055>; else goto <D.18056>;
      <D.18055>:
      start.1 = start;
      printf ("Pointer is the start of object %p in oldspace.\n", start.1);
      goto <D.18057>;
      <D.18056>:
      start.1 = start;
      if (start.1 != 0B) goto <D.18058>; else goto <D.18059>;
      <D.18058>:
      start.1 = start;
      ptr.2 = (int) ptr;
      start.1 = start;
      start.3 = (int) start.1;
      D.18049 = ptr.2 - start.3;
      printf ("Pointer is at offset 0x%x of object %p in oldspace.\n", D.18049, start.1);
      goto <D.18060>;
      <D.18059>:
      printf ("Pointer inside oldspace.\n");
      <D.18060>:
      <D.18057>:
      start.1 = start;
      if (start.1 != 0B) goto <D.18061>; else goto <D.18062>;
      <D.18061>:
      ptr = start;
      <D.18062>:
      D.18063 = major_collector.describe_pointer;
      vtable = D.18063 (ptr);
      goto <D.18064>;
      <D.18054>:
      D.18065 = major_collector.obj_is_from_pinned_alloc;
      D.18066 = D.18065 (ptr);
      if (D.18066 != 0) goto <D.18067>; else goto <D.18068>;
      <D.18067>:
      printf ("Pointer is inside a pinned chunk.\n");
      D.18038 = MEM[(mword *)ptr];
      D.18039 = D.18038 & 4294967292;
      vtable = (struct MonoVTable *) D.18039;
      goto <D.18069>;
      <D.18068>:
      printf ("Pointer unknown.\n");
      return;
      <D.18069>:
      <D.18064>:
      <D.18050>:
      <D.18040>:
      D.18038 = MEM[(mword *)ptr];
      D.18070 = D.18038 & 2;
      if (D.18070 != 0) goto <D.18071>; else goto <D.18072>;
      <D.18071>:
      printf ("Object is pinned.\n");
      <D.18072>:
      D.18038 = MEM[(mword *)ptr];
      D.18074 = D.18038 & 1;
      if (D.18074 != 0) goto <D.18075>; else goto <D.18076>;
      <D.18075>:
      D.18038 = MEM[(mword *)ptr];
      D.18039 = D.18038 & 4294967292;
      iftmp.4 = (char *) D.18039;
      goto <D.18077>;
      <D.18076>:
      iftmp.4 = 0B;
      <D.18077>:
      forwarded = iftmp.4;
      if (forwarded != 0B) goto <D.18078>; else goto <D.18079>;
      <D.18078>:
      printf ("Object is forwarded to %p:\n", forwarded);
      ptr = forwarded;
      goto restart;
      <D.18079>:
      printf ("VTable: %p\n", vtable);
      if (vtable == 0B) goto <D.18080>; else goto <D.18081>;
      <D.18080>:
      printf ("VTable is invalid (empty).\n");
      goto bridge;
      <D.18081>:
      D.18082 = sgen_ptr_in_nursery (vtable);
      if (D.18082 != 0) goto <D.18083>; else goto <D.18084>;
      <D.18083>:
      printf ("VTable is invalid (points inside nursery).\n");
      goto bridge;
      <D.18084>:
      D.18085 = vtable->klass;
      D.18086 = D.18085->name;
      printf ("Class: %s\n", D.18086);
      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.18089 = descriptor_types[type];
      printf ("Descriptor type: %d (%s)\n", type, D.18089);
      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.18098;
  char * * D.18099;
  char * D.18100;
  int valid_nursery_object_count.10;
  unsigned int D.18106;
  char * D.18107;
  int gc_debug_level.11;
  _Bool D.18109;
  long int D.18110;
  long int D.18111;
  struct FILE * gc_debug_file.12;
  char * D.18115;
  int ptr.13;
  int obj.14;
  int D.18125;
  int i;

  if (need_setup != 0) goto <D.18094>; else goto <D.18095>;
  <D.18094>:
  setup_valid_nursery_objects ();
  <D.18095>:
  i = 0;
  goto <D.17752>;
  <D.17751>:
  valid_nursery_objects.8 = valid_nursery_objects;
  i.9 = (unsigned int) i;
  D.18098 = i.9 * 4;
  D.18099 = valid_nursery_objects.8 + D.18098;
  D.18100 = *D.18099;
  if (D.18100 >= ptr) goto <D.17750>; else goto <D.18101>;
  <D.18101>:
  i = i + 1;
  <D.17752>:
  valid_nursery_object_count.10 = valid_nursery_object_count;
  if (i < valid_nursery_object_count.10) goto <D.17751>; else goto <D.17750>;
  <D.17750>:
  valid_nursery_object_count.10 = valid_nursery_object_count;
  if (i >= valid_nursery_object_count.10) goto <D.18103>; else goto <D.18105>;
  <D.18105>:
  valid_nursery_objects.8 = valid_nursery_objects;
  i.9 = (unsigned int) i;
  D.18098 = i.9 * 4;
  D.18099 = valid_nursery_objects.8 + D.18098;
  D.18100 = *D.18099;
  valid_nursery_objects.8 = valid_nursery_objects;
  i.9 = (unsigned int) i;
  D.18098 = i.9 * 4;
  D.18099 = valid_nursery_objects.8 + D.18098;
  D.18100 = *D.18099;
  D.18106 = sgen_safe_object_get_size (D.18100);
  D.18107 = D.18100 + D.18106;
  if (D.18107 < ptr) goto <D.18103>; else goto <D.18104>;
  <D.18103>:
  gc_debug_level.11 = gc_debug_level;
  D.18109 = gc_debug_level.11 >= 0;
  D.18110 = (long int) D.18109;
  D.18111 = __builtin_expect (D.18110, 0);
  if (D.18111 != 0) goto <D.18112>; else goto <D.18113>;
  <D.18112>:
  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.18113>:
  D.18115 = 0B;
  return D.18115;
  <D.18104>:
  {
    char * obj;

    valid_nursery_objects.8 = valid_nursery_objects;
    i.9 = (unsigned int) i;
    D.18098 = i.9 * 4;
    D.18099 = valid_nursery_objects.8 + D.18098;
    obj = *D.18099;
    if (obj == ptr) goto <D.18116>; else goto <D.18117>;
    <D.18116>:
    gc_debug_level.11 = gc_debug_level;
    D.18109 = gc_debug_level.11 >= 0;
    D.18110 = (long int) D.18109;
    D.18111 = __builtin_expect (D.18110, 0);
    if (D.18111 != 0) goto <D.18118>; else goto <D.18119>;
    <D.18118>:
    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.18119>:
    goto <D.18120>;
    <D.18117>:
    gc_debug_level.11 = gc_debug_level;
    D.18109 = gc_debug_level.11 >= 0;
    D.18110 = (long int) D.18109;
    D.18111 = __builtin_expect (D.18110, 0);
    if (D.18111 != 0) goto <D.18121>; else goto <D.18122>;
    <D.18121>:
    ptr.13 = (int) ptr;
    obj.14 = (int) obj;
    D.18125 = ptr.13 - obj.14;
    gc_debug_file.12 = gc_debug_file;
    fprintf (gc_debug_file.12, "nursery-ptr (interior-ptr offset %td)\n\n", D.18125);
    gc_debug_file.12 = gc_debug_file;
    fflush (gc_debug_file.12);
    <D.18122>:
    <D.18120>:
    D.18115 = obj;
    return D.18115;
  }
}


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.18134;
  char * D.18135;

  valid_nursery_objects.15 = valid_nursery_objects;
  if (valid_nursery_objects.15 == 0B) goto <D.18128>; else goto <D.18129>;
  <D.18128>:
  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.18129>:
  valid_nursery_object_count = 0;
  nursery_section.19 = nursery_section;
  D.18134 = nursery_section.19->end_data;
  nursery_section.19 = nursery_section;
  D.18135 = nursery_section.19->data;
  sgen_scan_area_with_callback (D.18135, D.18134, 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.18141;
  char * * D.18142;

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


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

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


sgen_ptr_in_nursery (void * p)
{
  gboolean D.18145;
  int sgen_nursery_bits.25;
  int D.18147;
  int D.18148;
  unsigned int D.18149;
  unsigned int p.26;
  unsigned int D.18151;
  char * sgen_nursery_start.27;
  unsigned int sgen_nursery_start.28;
  _Bool D.18154;

  sgen_nursery_bits.25 = sgen_nursery_bits;
  D.18147 = 1 << sgen_nursery_bits.25;
  D.18148 = -D.18147;
  D.18149 = (unsigned int) D.18148;
  p.26 = (unsigned int) p;
  D.18151 = D.18149 & p.26;
  sgen_nursery_start.27 = sgen_nursery_start;
  sgen_nursery_start.28 = (unsigned int) sgen_nursery_start.27;
  D.18154 = D.18151 == sgen_nursery_start.28;
  D.18145 = (gboolean) D.18154;
  return D.18145;
}


sgen_safe_object_get_size (struct MonoObject * obj)
{
  char * iftmp.29;
  unsigned int D.18157;
  unsigned int D.18158;
  unsigned int D.18161;
  guint D.18165;
  struct MonoVTable * D.18166;
  char * forwarded;

  D.18157 = MEM[(mword *)obj];
  D.18158 = D.18157 & 1;
  if (D.18158 != 0) goto <D.18159>; else goto <D.18160>;
  <D.18159>:
  D.18157 = MEM[(mword *)obj];
  D.18161 = D.18157 & 4294967292;
  iftmp.29 = (char *) D.18161;
  goto <D.18162>;
  <D.18160>:
  iftmp.29 = 0B;
  <D.18162>:
  forwarded = iftmp.29;
  if (forwarded != 0B) goto <D.18163>; else goto <D.18164>;
  <D.18163>:
  obj = forwarded;
  <D.18164>:
  D.18157 = MEM[(mword *)obj];
  D.18161 = D.18157 & 4294967292;
  D.18166 = (struct MonoVTable *) D.18161;
  D.18165 = sgen_par_object_get_size (D.18166, obj);
  return D.18165;
}


sgen_par_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  void * D.18168;
  unsigned int D.18169;
  guint D.18174;
  int D.18175;
  int D.18176;
  unsigned int D.18177;
  unsigned int D.18180;
  int D.18181;
  unsigned int D.18182;
  unsigned int element_size.30;
  unsigned int D.18184;
  unsigned int D.18185;
  struct MonoClass * D.18188;
  unsigned char D.18189;
  unsigned int D.18190;
  unsigned int D.18191;
  mword descr;
  mword type;

  D.18168 = vtable->gc_descr;
  descr = (mword) D.18168;
  type = descr & 7;
  D.18169 = type + 4294967295;
  if (D.18169 <= 1) goto <D.18170>; else goto <D.18171>;
  <D.18170>:
  {
    mword size;

    size = descr & 65528;
    if (size == 0) goto <D.18172>; else goto <D.18173>;
    <D.18172>:
    D.18175 = MEM[(struct MonoString *)o].length;
    D.18176 = D.18175 * 2;
    D.18177 = (unsigned int) D.18176;
    D.18174 = D.18177 + 14;
    return D.18174;
    <D.18173>:
    D.18174 = size;
    return D.18174;
  }
  <D.18171>:
  if (type == 4) goto <D.18178>; else goto <D.18179>;
  <D.18178>:
  {
    int element_size;
    struct MonoArray * array;
    size_t size;

    D.18180 = descr >> 3;
    D.18181 = (int) D.18180;
    element_size = D.18181 & 1023;
    array = o;
    D.18182 = array->max_length;
    element_size.30 = (unsigned int) element_size;
    D.18184 = D.18182 * element_size.30;
    size = D.18184 + 16;
    D.18185 = descr & 8192;
    if (D.18185 != 0) goto <D.18186>; else goto <D.18187>;
    <D.18186>:
    size = size + 3;
    size = size & 4294967292;
    D.18188 = vtable->klass;
    D.18189 = D.18188->rank;
    D.18190 = (unsigned int) D.18189;
    D.18191 = D.18190 * 8;
    size = D.18191 + size;
    <D.18187>:
    D.18174 = size;
    return D.18174;
  }
  <D.18179>:
  D.18174 = slow_object_get_size (vtable, o);
  return D.18174;
}


slow_object_get_size (struct MonoVTable * vtable, struct MonoObject * o)
{
  struct MonoClass * D.18193;
  guint D.18196;
  int D.18197;
  int D.18198;
  unsigned int D.18199;
  unsigned char D.18200;
  int D.18203;
  unsigned int D.18204;
  unsigned int D.18205;
  unsigned int D.18206;
  struct MonoArrayBounds * D.18207;
  _Bool D.18208;
  long int D.18209;
  long int D.18210;
  unsigned int D.18213;
  unsigned int D.18214;
  int D.18215;
  struct MonoClass * klass;

  klass = vtable->klass;
  D.18193 = mono_defaults.string_class;
  if (D.18193 == klass) goto <D.18194>; else goto <D.18195>;
  <D.18194>:
  D.18197 = MEM[(struct MonoString *)o].length;
  D.18198 = D.18197 * 2;
  D.18199 = (unsigned int) D.18198;
  D.18196 = D.18199 + 14;
  return D.18196;
  <D.18195>:
  D.18200 = klass->rank;
  if (D.18200 != 0) goto <D.18201>; else goto <D.18202>;
  <D.18201>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.18203 = klass->sizes.element_size;
    D.18204 = (unsigned int) D.18203;
    D.18205 = array->max_length;
    D.18206 = D.18204 * D.18205;
    size = D.18206 + 16;
    D.18207 = array->bounds;
    D.18208 = D.18207 != 0B;
    D.18209 = (long int) D.18208;
    D.18210 = __builtin_expect (D.18209, 0);
    if (D.18210 != 0) goto <D.18211>; else goto <D.18212>;
    <D.18211>:
    size = size + 3;
    size = size & 4294967292;
    D.18200 = klass->rank;
    D.18213 = (unsigned int) D.18200;
    D.18214 = D.18213 * 8;
    size = D.18214 + size;
    <D.18212>:
    D.18196 = size;
    return D.18196;
  }
  <D.18202>:
  D.18215 = klass->instance_size;
  D.18196 = (guint) D.18215;
  return D.18196;
}


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

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


sgen_check_consistency ()
{
  int gc_debug_level.31;
  _Bool D.18220;
  long int D.18221;
  long int D.18222;
  struct FILE * gc_debug_file.32;
  void (*<T2c44>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.18226;
  int missing_remsets.33;
  _Bool D.18232;
  long int D.18233;
  long int D.18234;

  missing_remsets = 0;
  gc_debug_level.31 = gc_debug_level;
  D.18220 = gc_debug_level.31 > 0;
  D.18221 = (long int) D.18220;
  D.18222 = __builtin_expect (D.18221, 0);
  if (D.18222 != 0) goto <D.18223>; else goto <D.18224>;
  <D.18223>:
  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.18224>:
  D.18226 = major_collector.iterate_objects;
  D.18226 (1, 1, check_consistency_callback, 0B);
  sgen_los_iterate_objects (check_consistency_callback, 0B);
  gc_debug_level.31 = gc_debug_level;
  D.18220 = gc_debug_level.31 > 0;
  D.18221 = (long int) D.18220;
  D.18222 = __builtin_expect (D.18221, 0);
  if (D.18222 != 0) goto <D.18227>; else goto <D.18228>;
  <D.18227>:
  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.18228>:
  if (1 != 0) goto <D.18229>; else goto <D.18230>;
  <D.18229>:
  missing_remsets.33 = missing_remsets;
  D.18232 = missing_remsets.33 != 0;
  D.18233 = (long int) D.18232;
  D.18234 = __builtin_expect (D.18233, 0);
  if (D.18234 != 0) goto <D.18235>; else goto <D.18236>;
  <D.18235>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 204, "!missing_remsets");
  <D.18236>:
  <D.18230>:
}


check_consistency_callback (char * start, size_t size, void * dummy)
{
  unsigned int D.18237;
  unsigned int D.18238;
  struct MonoClass * D.18241;
  const char * D.18242;
  struct FILE * gc_debug_file.34;
  unsigned int D.18244;
  unsigned int D.18245;
  unsigned int D.18248;
  unsigned int D.18249;
  unsigned int D.18250;
  unsigned int D.18251;
  unsigned int D.18252;
  void * D.18253;
  int D.18256;
  struct SgenRemeberedSet * D.18259;
  gboolean (*<T2bea>) (char *) D.18260;
  int D.18261;
  int gc_debug_level.35;
  _Bool D.18265;
  long int D.18266;
  long int D.18267;
  struct MonoVTable * D.18270;
  struct MonoClass * D.18271;
  const char * D.18272;
  const char * D.18273;
  int _objptr.36;
  int start.37;
  int D.18276;
  unsigned int D.18277;
  unsigned int D.18278;
  int D.18283;
  struct SgenRemeberedSet * D.18286;
  gboolean (*<T2bea>) (char *) D.18287;
  int D.18288;
  unsigned int _index.38;
  unsigned int D.18296;
  int D.18297;
  void * D.18298;
  int D.18301;
  struct SgenRemeberedSet * D.18304;
  gboolean (*<T2bea>) (char *) D.18305;
  int D.18306;
  int _objptr.39;
  int D.18312;
  unsigned int D.18313;
  unsigned int D.18314;
  unsigned int _index.40;
  unsigned int D.18318;
  int D.18319;
  int D.18322;
  struct SgenRemeberedSet * D.18325;
  gboolean (*<T2bea>) (char *) D.18326;
  int D.18327;
  unsigned int D.18334;
  unsigned int D.18337;
  int D.18338;
  int desc.41;
  unsigned int D.18342;
  unsigned int el_size.42;
  unsigned int D.18344;
  void * D.18345;
  int D.18348;
  struct SgenRemeberedSet * D.18351;
  gboolean (*<T2bea>) (char *) D.18352;
  int D.18353;
  int p.43;
  int D.18359;
  unsigned int D.18360;
  unsigned int D.18361;
  int D.18367;
  unsigned int offset.44;
  unsigned int D.18369;
  unsigned int i.45;
  unsigned int D.18371;
  void * * D.18372;
  void * D.18373;
  int D.18376;
  struct SgenRemeberedSet * D.18379;
  gboolean (*<T2bea>) (char *) D.18380;
  char * D.18381;
  int D.18382;
  int D.18387;
  int D.18388;
  unsigned int D.18389;
  unsigned int D.18390;
  sizetype el_size.46;
  unsigned int D.18397;
  void * D.18400;
  int D.18403;
  struct SgenRemeberedSet * D.18406;
  gboolean (*<T2bea>) (char *) D.18407;
  int D.18408;
  int p.47;
  int D.18414;
  unsigned int D.18415;
  unsigned int D.18416;
  unsigned int D.18419;
  void * D.18422;
  int D.18425;
  struct SgenRemeberedSet * D.18428;
  gboolean (*<T2bea>) (char *) D.18429;
  int D.18430;
  int _objptr.48;
  int D.18436;
  unsigned int D.18437;
  unsigned int D.18438;
  unsigned int D.18441;
  unsigned int D.18442;
  struct MonoVTable * D.18445;
  struct MonoClass * D.18446;
  const char * D.18447;
  const char * D.18448;
  gsize * bitmap_data.49;
  unsigned int D.18450;
  void * D.18453;
  int D.18456;
  struct SgenRemeberedSet * D.18459;
  gboolean (*<T2bea>) (char *) D.18460;
  int D.18461;
  int _objptr.50;
  int D.18467;
  unsigned int D.18468;
  unsigned int D.18469;
  int bwords.51;
  unsigned int D.18473;
  gsize * mbitmap_data.52;
  unsigned int D.18475;
  unsigned int D.18476;
  struct MonoClass * D.18477;
  unsigned int el_size.53;
  unsigned int D.18479;
  const char * D.18482;
  const char * D.18483;
  gsize * bitmap_data.54;
  unsigned int D.18485;
  void * D.18488;
  int D.18491;
  struct SgenRemeberedSet * D.18494;
  gboolean (*<T2bea>) (char *) D.18495;
  int D.18496;
  int _objptr.55;
  int D.18502;
  unsigned int D.18503;
  unsigned int D.18504;
  unsigned int bwords.56;
  sizetype el_size.57;
  struct GCVTable * vt;

  D.18237 = MEM[(mword *)start];
  D.18238 = D.18237 & 4294967292;
  vt = (struct GCVTable *) D.18238;
  if (0 != 0) goto <D.18239>; else goto <D.18240>;
  <D.18239>:
  D.18241 = vt->klass;
  D.18242 = D.18241->name;
  gc_debug_file.34 = gc_debug_file;
  fprintf (gc_debug_file.34, "Scanning object %p, vtable: %p (%s)\n", start, vt, D.18242);
  gc_debug_file.34 = gc_debug_file;
  fflush (gc_debug_file.34);
  <D.18240>:
  {
    struct GCVTable * vt;
    mword desc;

    D.18237 = MEM[(mword *)start];
    D.18238 = D.18237 & 4294967292;
    vt = (struct GCVTable *) D.18238;
    desc = vt->desc;
    D.18244 = desc & 7;
    switch (D.18244) <default: <D.17421>, case 1: <D.17336>, case 2: <D.17343>, case 3: <D.17387>, case 4: <D.17351>, case 5: <D.17381>, case 6: <D.17400>, case 7: <D.17420>>
    <D.17336>:
    D.18245 = desc & 4294901760;
    if (D.18245 != 0) goto <D.18246>; else goto <D.18247>;
    <D.18246>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.18248 = desc >> 16;
      D.18249 = D.18248 & 255;
      D.18250 = D.18249 * 4;
      _objptr = _objptr + D.18250;
      D.18251 = desc >> 24;
      D.18252 = D.18251 * 4;
      _objptr_end = _objptr + D.18252;
      D.18253 = *_objptr;
      if (D.18253 != 0B) goto <D.18254>; else goto <D.18255>;
      <D.18254>:
      D.18253 = *_objptr;
      D.18256 = sgen_ptr_in_nursery (D.18253);
      if (D.18256 != 0) goto <D.18257>; else goto <D.18258>;
      <D.18257>:
      D.18259 = sgen_get_remset ();
      D.18260 = D.18259->find_address;
      D.18261 = D.18260 (_objptr);
      if (D.18261 == 0) goto <D.18262>; else goto <D.18263>;
      <D.18262>:
      gc_debug_level.35 = gc_debug_level;
      D.18265 = gc_debug_level.35 >= 0;
      D.18266 = (long int) D.18265;
      D.18267 = __builtin_expect (D.18266, 0);
      if (D.18267 != 0) goto <D.18268>; else goto <D.18269>;
      <D.18268>:
      D.18270 = MEM[(struct MonoObject *)start].vtable;
      D.18271 = D.18270->klass;
      D.18272 = D.18271->name;
      D.18270 = MEM[(struct MonoObject *)start].vtable;
      D.18271 = D.18270->klass;
      D.18273 = D.18271->name_space;
      _objptr.36 = (int) _objptr;
      start.37 = (int) start;
      D.18276 = _objptr.36 - start.37;
      D.18253 = *_objptr;
      gc_debug_file.34 = gc_debug_file;
      fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18253, D.18276, start, D.18273, D.18272);
      gc_debug_file.34 = gc_debug_file;
      fflush (gc_debug_file.34);
      <D.18269>:
      D.18253 = *_objptr;
      D.18277 = MEM[(mword *)D.18253];
      D.18278 = D.18277 & 2;
      if (D.18278 == 0) goto <D.18279>; else goto <D.18280>;
      <D.18279>:
      missing_remsets = 1;
      <D.18280>:
      <D.18263>:
      <D.18258>:
      <D.18255>:
      _objptr = _objptr + 4;
      goto <D.17340>;
      <D.17339>:
      D.18253 = *_objptr;
      if (D.18253 != 0B) goto <D.18281>; else goto <D.18282>;
      <D.18281>:
      D.18253 = *_objptr;
      D.18283 = sgen_ptr_in_nursery (D.18253);
      if (D.18283 != 0) goto <D.18284>; else goto <D.18285>;
      <D.18284>:
      D.18286 = sgen_get_remset ();
      D.18287 = D.18286->find_address;
      D.18288 = D.18287 (_objptr);
      if (D.18288 == 0) goto <D.18289>; else goto <D.18290>;
      <D.18289>:
      gc_debug_level.35 = gc_debug_level;
      D.18265 = gc_debug_level.35 >= 0;
      D.18266 = (long int) D.18265;
      D.18267 = __builtin_expect (D.18266, 0);
      if (D.18267 != 0) goto <D.18291>; else goto <D.18292>;
      <D.18291>:
      D.18270 = MEM[(struct MonoObject *)start].vtable;
      D.18271 = D.18270->klass;
      D.18272 = D.18271->name;
      D.18270 = MEM[(struct MonoObject *)start].vtable;
      D.18271 = D.18270->klass;
      D.18273 = D.18271->name_space;
      _objptr.36 = (int) _objptr;
      start.37 = (int) start;
      D.18276 = _objptr.36 - start.37;
      D.18253 = *_objptr;
      gc_debug_file.34 = gc_debug_file;
      fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18253, D.18276, start, D.18273, D.18272);
      gc_debug_file.34 = gc_debug_file;
      fflush (gc_debug_file.34);
      <D.18292>:
      D.18253 = *_objptr;
      D.18277 = MEM[(mword *)D.18253];
      D.18278 = D.18277 & 2;
      if (D.18278 == 0) goto <D.18293>; else goto <D.18294>;
      <D.18293>:
      missing_remsets = 1;
      <D.18294>:
      <D.18290>:
      <D.18285>:
      <D.18282>:
      _objptr = _objptr + 4;
      <D.17340>:
      if (_objptr < _objptr_end) goto <D.17339>; else goto <D.17341>;
      <D.17341>:
    }
    <D.18247>:
    goto <D.17342>;
    <D.17343>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.38 = (unsigned int) _index;
        D.18296 = _index.38 * 4;
        _objptr = _objptr + D.18296;
        D.18297 = _index + 1;
        _bmap = _bmap >> D.18297;
        D.18298 = *_objptr;
        if (D.18298 != 0B) goto <D.18299>; else goto <D.18300>;
        <D.18299>:
        D.18298 = *_objptr;
        D.18301 = sgen_ptr_in_nursery (D.18298);
        if (D.18301 != 0) goto <D.18302>; else goto <D.18303>;
        <D.18302>:
        D.18304 = sgen_get_remset ();
        D.18305 = D.18304->find_address;
        D.18306 = D.18305 (_objptr);
        if (D.18306 == 0) goto <D.18307>; else goto <D.18308>;
        <D.18307>:
        gc_debug_level.35 = gc_debug_level;
        D.18265 = gc_debug_level.35 >= 0;
        D.18266 = (long int) D.18265;
        D.18267 = __builtin_expect (D.18266, 0);
        if (D.18267 != 0) goto <D.18309>; else goto <D.18310>;
        <D.18309>:
        D.18270 = MEM[(struct MonoObject *)start].vtable;
        D.18271 = D.18270->klass;
        D.18272 = D.18271->name;
        D.18270 = MEM[(struct MonoObject *)start].vtable;
        D.18271 = D.18270->klass;
        D.18273 = D.18271->name_space;
        _objptr.39 = (int) _objptr;
        start.37 = (int) start;
        D.18312 = _objptr.39 - start.37;
        D.18298 = *_objptr;
        gc_debug_file.34 = gc_debug_file;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18298, D.18312, start, D.18273, D.18272);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.18310>:
        D.18298 = *_objptr;
        D.18313 = MEM[(mword *)D.18298];
        D.18314 = D.18313 & 2;
        if (D.18314 == 0) goto <D.18315>; else goto <D.18316>;
        <D.18315>:
        missing_remsets = 1;
        <D.18316>:
        <D.18308>:
        <D.18303>:
        <D.18300>:
        _objptr = _objptr + 4;
      }
      goto <D.17349>;
      <D.17348>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.40 = (unsigned int) _index;
        D.18318 = _index.40 * 4;
        _objptr = _objptr + D.18318;
        D.18319 = _index + 1;
        _bmap = _bmap >> D.18319;
        D.18298 = *_objptr;
        if (D.18298 != 0B) goto <D.18320>; else goto <D.18321>;
        <D.18320>:
        D.18298 = *_objptr;
        D.18322 = sgen_ptr_in_nursery (D.18298);
        if (D.18322 != 0) goto <D.18323>; else goto <D.18324>;
        <D.18323>:
        D.18325 = sgen_get_remset ();
        D.18326 = D.18325->find_address;
        D.18327 = D.18326 (_objptr);
        if (D.18327 == 0) goto <D.18328>; else goto <D.18329>;
        <D.18328>:
        gc_debug_level.35 = gc_debug_level;
        D.18265 = gc_debug_level.35 >= 0;
        D.18266 = (long int) D.18265;
        D.18267 = __builtin_expect (D.18266, 0);
        if (D.18267 != 0) goto <D.18330>; else goto <D.18331>;
        <D.18330>:
        D.18270 = MEM[(struct MonoObject *)start].vtable;
        D.18271 = D.18270->klass;
        D.18272 = D.18271->name;
        D.18270 = MEM[(struct MonoObject *)start].vtable;
        D.18271 = D.18270->klass;
        D.18273 = D.18271->name_space;
        _objptr.39 = (int) _objptr;
        start.37 = (int) start;
        D.18312 = _objptr.39 - start.37;
        D.18298 = *_objptr;
        gc_debug_file.34 = gc_debug_file;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18298, D.18312, start, D.18273, D.18272);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.18331>:
        D.18298 = *_objptr;
        D.18313 = MEM[(mword *)D.18298];
        D.18314 = D.18313 & 2;
        if (D.18314 == 0) goto <D.18332>; else goto <D.18333>;
        <D.18332>:
        missing_remsets = 1;
        <D.18333>:
        <D.18329>:
        <D.18324>:
        <D.18321>:
        _objptr = _objptr + 4;
      }
      <D.17349>:
      if (_bmap != 0) goto <D.17348>; else goto <D.17350>;
      <D.17350>:
    }
    goto <D.17342>;
    <D.17351>:
    D.18334 = desc & 4294950912;
    if (D.18334 != 0) goto <D.18335>; else goto <D.18336>;
    <D.18335>:
    {
      int el_size;
      int etype;

      D.18337 = desc >> 3;
      D.18338 = (int) D.18337;
      el_size = D.18338 & 1023;
      desc.41 = (int) desc;
      etype = desc.41 & 49152;
      if (etype == 16384) goto <D.18340>; else goto <D.18341>;
      <D.18340>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.18342 = MEM[(struct MonoArray *)start].max_length;
        el_size.42 = (unsigned int) el_size;
        D.18344 = D.18342 * el_size.42;
        end_refs = p + D.18344;
        goto <D.17357>;
        <D.17356>:
        D.18345 = *p;
        if (D.18345 != 0B) goto <D.18346>; else goto <D.18347>;
        <D.18346>:
        D.18345 = *p;
        D.18348 = sgen_ptr_in_nursery (D.18345);
        if (D.18348 != 0) goto <D.18349>; else goto <D.18350>;
        <D.18349>:
        D.18351 = sgen_get_remset ();
        D.18352 = D.18351->find_address;
        D.18353 = D.18352 (p);
        if (D.18353 == 0) goto <D.18354>; else goto <D.18355>;
        <D.18354>:
        gc_debug_level.35 = gc_debug_level;
        D.18265 = gc_debug_level.35 >= 0;
        D.18266 = (long int) D.18265;
        D.18267 = __builtin_expect (D.18266, 0);
        if (D.18267 != 0) goto <D.18356>; else goto <D.18357>;
        <D.18356>:
        D.18270 = MEM[(struct MonoObject *)start].vtable;
        D.18271 = D.18270->klass;
        D.18272 = D.18271->name;
        D.18270 = MEM[(struct MonoObject *)start].vtable;
        D.18271 = D.18270->klass;
        D.18273 = D.18271->name_space;
        p.43 = (int) p;
        start.37 = (int) start;
        D.18359 = p.43 - start.37;
        D.18345 = *p;
        gc_debug_file.34 = gc_debug_file;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18345, D.18359, start, D.18273, D.18272);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.18357>:
        D.18345 = *p;
        D.18360 = MEM[(mword *)D.18345];
        D.18361 = D.18360 & 2;
        if (D.18361 == 0) goto <D.18362>; else goto <D.18363>;
        <D.18362>:
        missing_remsets = 1;
        <D.18363>:
        <D.18355>:
        <D.18350>:
        <D.18347>:
        p = p + 4;
        <D.17357>:
        if (p < end_refs) goto <D.17356>; else goto <D.17358>;
        <D.17358>:
      }
      goto <D.18364>;
      <D.18341>:
      if (etype == 32768) goto <D.18365>; else goto <D.18366>;
      <D.18365>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.18248 = desc >> 16;
        D.18367 = (int) D.18248;
        offset = D.18367 & 255;
        D.18251 = desc >> 24;
        num_refs = (int) D.18251;
        e_start = start + 16;
        D.18342 = MEM[(struct MonoArray *)start].max_length;
        el_size.42 = (unsigned int) el_size;
        D.18344 = D.18342 * el_size.42;
        e_end = e_start + D.18344;
        goto <D.17369>;
        <D.17368>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.44 = (unsigned int) offset;
          D.18369 = offset.44 * 4;
          p = p + D.18369;
          i = 0;
          goto <D.17366>;
          <D.17365>:
          i.45 = (unsigned int) i;
          D.18371 = i.45 * 4;
          D.18372 = p + D.18371;
          D.18373 = *D.18372;
          if (D.18373 != 0B) goto <D.18374>; else goto <D.18375>;
          <D.18374>:
          i.45 = (unsigned int) i;
          D.18371 = i.45 * 4;
          D.18372 = p + D.18371;
          D.18373 = *D.18372;
          D.18376 = sgen_ptr_in_nursery (D.18373);
          if (D.18376 != 0) goto <D.18377>; else goto <D.18378>;
          <D.18377>:
          D.18379 = sgen_get_remset ();
          D.18380 = D.18379->find_address;
          i.45 = (unsigned int) i;
          D.18371 = i.45 * 4;
          D.18381 = p + D.18371;
          D.18382 = D.18380 (D.18381);
          if (D.18382 == 0) goto <D.18383>; else goto <D.18384>;
          <D.18383>:
          gc_debug_level.35 = gc_debug_level;
          D.18265 = gc_debug_level.35 >= 0;
          D.18266 = (long int) D.18265;
          D.18267 = __builtin_expect (D.18266, 0);
          if (D.18267 != 0) goto <D.18385>; else goto <D.18386>;
          <D.18385>:
          D.18270 = MEM[(struct MonoObject *)start].vtable;
          D.18271 = D.18270->klass;
          D.18272 = D.18271->name;
          D.18270 = MEM[(struct MonoObject *)start].vtable;
          D.18271 = D.18270->klass;
          D.18273 = D.18271->name_space;
          i.45 = (unsigned int) i;
          D.18371 = i.45 * 4;
          D.18381 = p + D.18371;
          D.18387 = (int) D.18381;
          start.37 = (int) start;
          D.18388 = D.18387 - start.37;
          i.45 = (unsigned int) i;
          D.18371 = i.45 * 4;
          D.18372 = p + D.18371;
          D.18373 = *D.18372;
          gc_debug_file.34 = gc_debug_file;
          fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18373, D.18388, start, D.18273, D.18272);
          gc_debug_file.34 = gc_debug_file;
          fflush (gc_debug_file.34);
          <D.18386>:
          i.45 = (unsigned int) i;
          D.18371 = i.45 * 4;
          D.18372 = p + D.18371;
          D.18373 = *D.18372;
          D.18389 = MEM[(mword *)D.18373];
          D.18390 = D.18389 & 2;
          if (D.18390 == 0) goto <D.18391>; else goto <D.18392>;
          <D.18391>:
          missing_remsets = 1;
          <D.18392>:
          <D.18384>:
          <D.18378>:
          <D.18375>:
          i = i + 1;
          <D.17366>:
          if (i < num_refs) goto <D.17365>; else goto <D.17367>;
          <D.17367>:
          el_size.46 = (sizetype) el_size;
          e_start = e_start + el_size.46;
        }
        <D.17369>:
        if (e_start < e_end) goto <D.17368>; else goto <D.17370>;
        <D.17370>:
      }
      goto <D.18394>;
      <D.18366>:
      if (etype == 49152) goto <D.18395>; else goto <D.18396>;
      <D.18395>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.18342 = MEM[(struct MonoArray *)start].max_length;
        el_size.42 = (unsigned int) el_size;
        D.18344 = D.18342 * el_size.42;
        e_end = e_start + D.18344;
        goto <D.17379>;
        <D.17378>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17376>;
          <D.17375>:
          D.18397 = _bmap & 1;
          if (D.18397 != 0) goto <D.18398>; else goto <D.18399>;
          <D.18398>:
          D.18400 = *p;
          if (D.18400 != 0B) goto <D.18401>; else goto <D.18402>;
          <D.18401>:
          D.18400 = *p;
          D.18403 = sgen_ptr_in_nursery (D.18400);
          if (D.18403 != 0) goto <D.18404>; else goto <D.18405>;
          <D.18404>:
          D.18406 = sgen_get_remset ();
          D.18407 = D.18406->find_address;
          D.18408 = D.18407 (p);
          if (D.18408 == 0) goto <D.18409>; else goto <D.18410>;
          <D.18409>:
          gc_debug_level.35 = gc_debug_level;
          D.18265 = gc_debug_level.35 >= 0;
          D.18266 = (long int) D.18265;
          D.18267 = __builtin_expect (D.18266, 0);
          if (D.18267 != 0) goto <D.18411>; else goto <D.18412>;
          <D.18411>:
          D.18270 = MEM[(struct MonoObject *)start].vtable;
          D.18271 = D.18270->klass;
          D.18272 = D.18271->name;
          D.18270 = MEM[(struct MonoObject *)start].vtable;
          D.18271 = D.18270->klass;
          D.18273 = D.18271->name_space;
          p.47 = (int) p;
          start.37 = (int) start;
          D.18414 = p.47 - start.37;
          D.18400 = *p;
          gc_debug_file.34 = gc_debug_file;
          fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18400, D.18414, start, D.18273, D.18272);
          gc_debug_file.34 = gc_debug_file;
          fflush (gc_debug_file.34);
          <D.18412>:
          D.18400 = *p;
          D.18415 = MEM[(mword *)D.18400];
          D.18416 = D.18415 & 2;
          if (D.18416 == 0) goto <D.18417>; else goto <D.18418>;
          <D.18417>:
          missing_remsets = 1;
          <D.18418>:
          <D.18410>:
          <D.18405>:
          <D.18402>:
          <D.18399>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17376>:
          if (_bmap != 0) goto <D.17375>; else goto <D.17377>;
          <D.17377>:
          el_size.46 = (sizetype) el_size;
          e_start = e_start + el_size.46;
        }
        <D.17379>:
        if (e_start < e_end) goto <D.17378>; else goto <D.17380>;
        <D.17380>:
      }
      <D.18396>:
      <D.18394>:
      <D.18364>:
    }
    <D.18336>:
    goto <D.17342>;
    <D.17381>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17385>;
      <D.17384>:
      D.18419 = _bmap & 1;
      if (D.18419 != 0) goto <D.18420>; else goto <D.18421>;
      <D.18420>:
      D.18422 = *_objptr;
      if (D.18422 != 0B) goto <D.18423>; else goto <D.18424>;
      <D.18423>:
      D.18422 = *_objptr;
      D.18425 = sgen_ptr_in_nursery (D.18422);
      if (D.18425 != 0) goto <D.18426>; else goto <D.18427>;
      <D.18426>:
      D.18428 = sgen_get_remset ();
      D.18429 = D.18428->find_address;
      D.18430 = D.18429 (_objptr);
      if (D.18430 == 0) goto <D.18431>; else goto <D.18432>;
      <D.18431>:
      gc_debug_level.35 = gc_debug_level;
      D.18265 = gc_debug_level.35 >= 0;
      D.18266 = (long int) D.18265;
      D.18267 = __builtin_expect (D.18266, 0);
      if (D.18267 != 0) goto <D.18433>; else goto <D.18434>;
      <D.18433>:
      D.18270 = MEM[(struct MonoObject *)start].vtable;
      D.18271 = D.18270->klass;
      D.18272 = D.18271->name;
      D.18270 = MEM[(struct MonoObject *)start].vtable;
      D.18271 = D.18270->klass;
      D.18273 = D.18271->name_space;
      _objptr.48 = (int) _objptr;
      start.37 = (int) start;
      D.18436 = _objptr.48 - start.37;
      D.18422 = *_objptr;
      gc_debug_file.34 = gc_debug_file;
      fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18422, D.18436, start, D.18273, D.18272);
      gc_debug_file.34 = gc_debug_file;
      fflush (gc_debug_file.34);
      <D.18434>:
      D.18422 = *_objptr;
      D.18437 = MEM[(mword *)D.18422];
      D.18438 = D.18437 & 2;
      if (D.18438 == 0) goto <D.18439>; else goto <D.18440>;
      <D.18439>:
      missing_remsets = 1;
      <D.18440>:
      <D.18432>:
      <D.18427>:
      <D.18424>:
      <D.18421>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17385>:
      if (_bmap != 0) goto <D.17384>; else goto <D.17386>;
      <D.17386>:
    }
    goto <D.17342>;
    <D.17387>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.18441 = *bitmap_data;
      D.18442 = D.18441 + 4294967295;
      bwords = (int) D.18442;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.18443>; else goto <D.18444>;
      <D.18443>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.18445 = myobj->vtable;
        D.18446 = D.18445->klass;
        D.18447 = D.18446->name;
        D.18445 = myobj->vtable;
        D.18446 = D.18445->klass;
        D.18448 = D.18446->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18448, D.18447);
      }
      <D.18444>:
      goto <D.17398>;
      <D.17397>:
      {
        gsize _bmap;

        bitmap_data.49 = bitmap_data;
        bitmap_data = bitmap_data.49 + 4;
        _bmap = *bitmap_data.49;
        _objptr = start_run;
        goto <D.17395>;
        <D.17394>:
        D.18450 = _bmap & 1;
        if (D.18450 != 0) goto <D.18451>; else goto <D.18452>;
        <D.18451>:
        D.18453 = *_objptr;
        if (D.18453 != 0B) goto <D.18454>; else goto <D.18455>;
        <D.18454>:
        D.18453 = *_objptr;
        D.18456 = sgen_ptr_in_nursery (D.18453);
        if (D.18456 != 0) goto <D.18457>; else goto <D.18458>;
        <D.18457>:
        D.18459 = sgen_get_remset ();
        D.18460 = D.18459->find_address;
        D.18461 = D.18460 (_objptr);
        if (D.18461 == 0) goto <D.18462>; else goto <D.18463>;
        <D.18462>:
        gc_debug_level.35 = gc_debug_level;
        D.18265 = gc_debug_level.35 >= 0;
        D.18266 = (long int) D.18265;
        D.18267 = __builtin_expect (D.18266, 0);
        if (D.18267 != 0) goto <D.18464>; else goto <D.18465>;
        <D.18464>:
        D.18270 = MEM[(struct MonoObject *)start].vtable;
        D.18271 = D.18270->klass;
        D.18272 = D.18271->name;
        D.18270 = MEM[(struct MonoObject *)start].vtable;
        D.18271 = D.18270->klass;
        D.18273 = D.18271->name_space;
        _objptr.50 = (int) _objptr;
        start.37 = (int) start;
        D.18467 = _objptr.50 - start.37;
        D.18453 = *_objptr;
        gc_debug_file.34 = gc_debug_file;
        fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18453, D.18467, start, D.18273, D.18272);
        gc_debug_file.34 = gc_debug_file;
        fflush (gc_debug_file.34);
        <D.18465>:
        D.18453 = *_objptr;
        D.18468 = MEM[(mword *)D.18453];
        D.18469 = D.18468 & 2;
        if (D.18469 == 0) goto <D.18470>; else goto <D.18471>;
        <D.18470>:
        missing_remsets = 1;
        <D.18471>:
        <D.18463>:
        <D.18458>:
        <D.18455>:
        <D.18452>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17395>:
        if (_bmap != 0) goto <D.17394>; else goto <D.17396>;
        <D.17396>:
        start_run = start_run + 128;
      }
      <D.17398>:
      bwords.51 = bwords;
      bwords = bwords.51 + -1;
      if (bwords.51 > 0) goto <D.17397>; else goto <D.17399>;
      <D.17399>:
    }
    goto <D.17342>;
    <D.17400>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.18473 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.18473);
      mbitmap_data.52 = mbitmap_data;
      mbitmap_data = mbitmap_data.52 + 4;
      D.18475 = *mbitmap_data.52;
      D.18476 = D.18475 + 4294967295;
      mbwords = (int) D.18476;
      D.18477 = vt->klass;
      el_size = mono_array_element_size (D.18477);
      e_start = start + 16;
      D.18342 = MEM[(struct MonoArray *)start].max_length;
      el_size.53 = (unsigned int) el_size;
      D.18479 = D.18342 * el_size.53;
      e_end = e_start + D.18479;
      if (0 != 0) goto <D.18480>; else goto <D.18481>;
      <D.18480>:
      D.18477 = vt->klass;
      D.18482 = D.18477->name;
      D.18477 = vt->klass;
      D.18483 = D.18477->name_space;
      D.18473 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.18473, D.18483, D.18482);
      <D.18481>:
      goto <D.17418>;
      <D.17417>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.17415>;
        <D.17414>:
        {
          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.17412>;
          <D.17411>:
          D.18485 = _bmap & 1;
          if (D.18485 != 0) goto <D.18486>; else goto <D.18487>;
          <D.18486>:
          D.18488 = *_objptr;
          if (D.18488 != 0B) goto <D.18489>; else goto <D.18490>;
          <D.18489>:
          D.18488 = *_objptr;
          D.18491 = sgen_ptr_in_nursery (D.18488);
          if (D.18491 != 0) goto <D.18492>; else goto <D.18493>;
          <D.18492>:
          D.18494 = sgen_get_remset ();
          D.18495 = D.18494->find_address;
          D.18496 = D.18495 (_objptr);
          if (D.18496 == 0) goto <D.18497>; else goto <D.18498>;
          <D.18497>:
          gc_debug_level.35 = gc_debug_level;
          D.18265 = gc_debug_level.35 >= 0;
          D.18266 = (long int) D.18265;
          D.18267 = __builtin_expect (D.18266, 0);
          if (D.18267 != 0) goto <D.18499>; else goto <D.18500>;
          <D.18499>:
          D.18270 = MEM[(struct MonoObject *)start].vtable;
          D.18271 = D.18270->klass;
          D.18272 = D.18271->name;
          D.18270 = MEM[(struct MonoObject *)start].vtable;
          D.18271 = D.18270->klass;
          D.18273 = D.18271->name_space;
          _objptr.55 = (int) _objptr;
          start.37 = (int) start;
          D.18502 = _objptr.55 - start.37;
          D.18488 = *_objptr;
          gc_debug_file.34 = gc_debug_file;
          fprintf (gc_debug_file.34, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18488, D.18502, start, D.18273, D.18272);
          gc_debug_file.34 = gc_debug_file;
          fflush (gc_debug_file.34);
          <D.18500>:
          D.18488 = *_objptr;
          D.18503 = MEM[(mword *)D.18488];
          D.18504 = D.18503 & 2;
          if (D.18504 == 0) goto <D.18505>; else goto <D.18506>;
          <D.18505>:
          missing_remsets = 1;
          <D.18506>:
          <D.18498>:
          <D.18493>:
          <D.18490>:
          <D.18487>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17412>:
          if (_bmap != 0) goto <D.17411>; else goto <D.17413>;
          <D.17413>:
          _objptr = start_run + 128;
        }
        <D.17415>:
        bwords.56 = bwords;
        bwords = bwords.56 + 4294967295;
        if (bwords.56 != 0) goto <D.17414>; else goto <D.17416>;
        <D.17416>:
        el_size.57 = (sizetype) el_size;
        e_start = e_start + el_size.57;
      }
      <D.17418>:
      if (e_start < e_end) goto <D.17417>; else goto <D.17419>;
      <D.17419>:
    }
    goto <D.17342>;
    <D.17420>:
    goto <D.17342>;
    <D.17421>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17342>:
  }
}


sgen_check_mod_union_consistency ()
{
  void (*<T2c44>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.18510;
  int missing_remsets.58;
  _Bool D.18514;
  long int D.18515;
  long int D.18516;

  missing_remsets = 0;
  D.18510 = major_collector.iterate_objects;
  D.18510 (1, 1, check_mod_union_callback, 0B);
  sgen_los_iterate_objects (check_mod_union_callback, 1B);
  if (1 != 0) goto <D.18511>; else goto <D.18512>;
  <D.18511>:
  missing_remsets.58 = missing_remsets;
  D.18514 = missing_remsets.58 != 0;
  D.18515 = (long int) D.18514;
  D.18516 = __builtin_expect (D.18515, 0);
  if (D.18516 != 0) goto <D.18517>; else goto <D.18518>;
  <D.18517>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 258, "!missing_remsets");
  <D.18518>:
  <D.18512>:
}


check_mod_union_callback (char * start, size_t size, void * dummy)
{
  unsigned int D.18519;
  unsigned int D.18520;
  struct MonoClass * D.18523;
  const char * D.18524;
  struct FILE * gc_debug_file.59;
  int D.18526;
  struct LOSObject * D.18531;
  struct SgenMajorCollector * D.18533;
  guint8 * (*<T2c87>) (char *) D.18534;
  _Bool D.18535;
  long int D.18536;
  long int D.18537;
  unsigned int D.18540;
  unsigned int D.18541;
  unsigned int D.18544;
  unsigned int D.18545;
  unsigned int D.18546;
  unsigned int D.18547;
  unsigned int D.18548;
  void * D.18549;
  int D.18552;
  int D.18555;
  struct SgenRemeberedSet * D.18558;
  gboolean (*<T2cc5>) (char *, guint8 *, char *) D.18559;
  int D.18560;
  int gc_debug_level.60;
  _Bool D.18564;
  long int D.18565;
  long int D.18566;
  struct MonoVTable * D.18569;
  struct MonoClass * D.18570;
  const char * D.18571;
  const char * D.18572;
  int _objptr.61;
  int start.62;
  int D.18575;
  int D.18578;
  int D.18581;
  struct SgenRemeberedSet * D.18584;
  gboolean (*<T2cc5>) (char *, guint8 *, char *) D.18585;
  int D.18586;
  unsigned int _index.63;
  unsigned int D.18592;
  int D.18593;
  void * D.18594;
  int D.18597;
  int D.18600;
  struct SgenRemeberedSet * D.18603;
  gboolean (*<T2cc5>) (char *, guint8 *, char *) D.18604;
  int D.18605;
  int _objptr.64;
  int D.18611;
  unsigned int _index.65;
  unsigned int D.18613;
  int D.18614;
  int D.18617;
  int D.18620;
  struct SgenRemeberedSet * D.18623;
  gboolean (*<T2cc5>) (char *, guint8 *, char *) D.18624;
  int D.18625;
  unsigned int D.18630;
  unsigned int D.18633;
  int D.18634;
  int desc.66;
  unsigned int D.18638;
  unsigned int el_size.67;
  unsigned int D.18640;
  void * D.18641;
  int D.18644;
  int D.18647;
  struct SgenRemeberedSet * D.18650;
  gboolean (*<T2cc5>) (char *, guint8 *, char *) D.18651;
  int D.18652;
  int p.68;
  int D.18658;
  int D.18662;
  unsigned int offset.69;
  unsigned int D.18664;
  unsigned int i.70;
  unsigned int D.18666;
  void * * D.18667;
  void * D.18668;
  int D.18671;
  int D.18674;
  struct SgenRemeberedSet * D.18677;
  gboolean (*<T2cc5>) (char *, guint8 *, char *) D.18678;
  char * D.18679;
  int D.18680;
  int D.18685;
  int D.18686;
  sizetype el_size.71;
  unsigned int D.18691;
  void * D.18694;
  int D.18697;
  int D.18700;
  struct SgenRemeberedSet * D.18703;
  gboolean (*<T2cc5>) (char *, guint8 *, char *) D.18704;
  int D.18705;
  int p.72;
  int D.18711;
  unsigned int D.18712;
  void * D.18715;
  int D.18718;
  int D.18721;
  struct SgenRemeberedSet * D.18724;
  gboolean (*<T2cc5>) (char *, guint8 *, char *) D.18725;
  int D.18726;
  int _objptr.73;
  int D.18732;
  unsigned int D.18733;
  unsigned int D.18734;
  struct MonoVTable * D.18737;
  struct MonoClass * D.18738;
  const char * D.18739;
  const char * D.18740;
  gsize * bitmap_data.74;
  unsigned int D.18742;
  void * D.18745;
  int D.18748;
  int D.18751;
  struct SgenRemeberedSet * D.18754;
  gboolean (*<T2cc5>) (char *, guint8 *, char *) D.18755;
  int D.18756;
  int _objptr.75;
  int D.18762;
  int bwords.76;
  unsigned int D.18764;
  gsize * mbitmap_data.77;
  unsigned int D.18766;
  unsigned int D.18767;
  struct MonoClass * D.18768;
  unsigned int el_size.78;
  unsigned int D.18770;
  const char * D.18773;
  const char * D.18774;
  gsize * bitmap_data.79;
  unsigned int D.18776;
  void * D.18779;
  int D.18782;
  int D.18785;
  struct SgenRemeberedSet * D.18788;
  gboolean (*<T2cc5>) (char *, guint8 *, char *) D.18789;
  int D.18790;
  int _objptr.80;
  int D.18796;
  unsigned int bwords.81;
  sizetype el_size.82;
  gboolean in_los;
  struct GCVTable * vt;
  guint8 * cards;

  in_los = (gboolean) dummy;
  D.18519 = MEM[(mword *)start];
  D.18520 = D.18519 & 4294967292;
  vt = (struct GCVTable *) D.18520;
  if (0 != 0) goto <D.18521>; else goto <D.18522>;
  <D.18521>:
  D.18523 = vt->klass;
  D.18524 = D.18523->name;
  gc_debug_file.59 = gc_debug_file;
  fprintf (gc_debug_file.59, "Scanning object %p, vtable: %p (%s)\n", start, vt, D.18524);
  gc_debug_file.59 = gc_debug_file;
  fflush (gc_debug_file.59);
  <D.18522>:
  D.18526 = is_major_or_los_object_marked (start);
  if (D.18526 == 0) goto <D.18527>; else goto <D.18528>;
  <D.18527>:
  return;
  <D.18528>:
  if (in_los != 0) goto <D.18529>; else goto <D.18530>;
  <D.18529>:
  D.18531 = sgen_los_header_for_object (start);
  cards = D.18531->cardtable_mod_union;
  goto <D.18532>;
  <D.18530>:
  D.18533 = sgen_get_major_collector ();
  D.18534 = D.18533->get_cardtable_mod_union_for_object;
  cards = D.18534 (start);
  <D.18532>:
  D.18535 = cards == 0B;
  D.18536 = (long int) D.18535;
  D.18537 = __builtin_expect (D.18536, 0);
  if (D.18537 != 0) goto <D.18538>; else goto <D.18539>;
  <D.18538>:
  monoeg_g_log (0B, 4, "we must have mod union for marked major objects");
  <D.17436>:
  goto <D.17436>;
  <D.18539>:
  {
    struct GCVTable * vt;
    mword desc;

    D.18519 = MEM[(mword *)start];
    D.18520 = D.18519 & 4294967292;
    vt = (struct GCVTable *) D.18520;
    desc = vt->desc;
    D.18540 = desc & 7;
    switch (D.18540) <default: <D.17524>, case 1: <D.17439>, case 2: <D.17446>, case 3: <D.17490>, case 4: <D.17454>, case 5: <D.17484>, case 6: <D.17503>, case 7: <D.17523>>
    <D.17439>:
    D.18541 = desc & 4294901760;
    if (D.18541 != 0) goto <D.18542>; else goto <D.18543>;
    <D.18542>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.18544 = desc >> 16;
      D.18545 = D.18544 & 255;
      D.18546 = D.18545 * 4;
      _objptr = _objptr + D.18546;
      D.18547 = desc >> 24;
      D.18548 = D.18547 * 4;
      _objptr_end = _objptr + D.18548;
      D.18549 = *_objptr;
      if (D.18549 != 0B) goto <D.18550>; else goto <D.18551>;
      <D.18550>:
      D.18549 = *_objptr;
      D.18552 = sgen_ptr_in_nursery (D.18549);
      if (D.18552 == 0) goto <D.18553>; else goto <D.18554>;
      <D.18553>:
      D.18549 = *_objptr;
      D.18555 = is_major_or_los_object_marked (D.18549);
      if (D.18555 == 0) goto <D.18556>; else goto <D.18557>;
      <D.18556>:
      D.18558 = sgen_get_remset ();
      D.18559 = D.18558->find_address_with_cards;
      D.18560 = D.18559 (start, cards, _objptr);
      if (D.18560 == 0) goto <D.18561>; else goto <D.18562>;
      <D.18561>:
      gc_debug_level.60 = gc_debug_level;
      D.18564 = gc_debug_level.60 >= 0;
      D.18565 = (long int) D.18564;
      D.18566 = __builtin_expect (D.18565, 0);
      if (D.18566 != 0) goto <D.18567>; else goto <D.18568>;
      <D.18567>:
      D.18569 = MEM[(struct MonoObject *)start].vtable;
      D.18570 = D.18569->klass;
      D.18571 = D.18570->name;
      D.18569 = MEM[(struct MonoObject *)start].vtable;
      D.18570 = D.18569->klass;
      D.18572 = D.18570->name_space;
      _objptr.61 = (int) _objptr;
      start.62 = (int) start;
      D.18575 = _objptr.61 - start.62;
      D.18549 = *_objptr;
      gc_debug_file.59 = gc_debug_file;
      fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18549, D.18575, start, D.18572, D.18571);
      gc_debug_file.59 = gc_debug_file;
      fflush (gc_debug_file.59);
      <D.18568>:
      <D.18562>:
      <D.18557>:
      <D.18554>:
      <D.18551>:
      _objptr = _objptr + 4;
      goto <D.17443>;
      <D.17442>:
      D.18549 = *_objptr;
      if (D.18549 != 0B) goto <D.18576>; else goto <D.18577>;
      <D.18576>:
      D.18549 = *_objptr;
      D.18578 = sgen_ptr_in_nursery (D.18549);
      if (D.18578 == 0) goto <D.18579>; else goto <D.18580>;
      <D.18579>:
      D.18549 = *_objptr;
      D.18581 = is_major_or_los_object_marked (D.18549);
      if (D.18581 == 0) goto <D.18582>; else goto <D.18583>;
      <D.18582>:
      D.18584 = sgen_get_remset ();
      D.18585 = D.18584->find_address_with_cards;
      D.18586 = D.18585 (start, cards, _objptr);
      if (D.18586 == 0) goto <D.18587>; else goto <D.18588>;
      <D.18587>:
      gc_debug_level.60 = gc_debug_level;
      D.18564 = gc_debug_level.60 >= 0;
      D.18565 = (long int) D.18564;
      D.18566 = __builtin_expect (D.18565, 0);
      if (D.18566 != 0) goto <D.18589>; else goto <D.18590>;
      <D.18589>:
      D.18569 = MEM[(struct MonoObject *)start].vtable;
      D.18570 = D.18569->klass;
      D.18571 = D.18570->name;
      D.18569 = MEM[(struct MonoObject *)start].vtable;
      D.18570 = D.18569->klass;
      D.18572 = D.18570->name_space;
      _objptr.61 = (int) _objptr;
      start.62 = (int) start;
      D.18575 = _objptr.61 - start.62;
      D.18549 = *_objptr;
      gc_debug_file.59 = gc_debug_file;
      fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18549, D.18575, start, D.18572, D.18571);
      gc_debug_file.59 = gc_debug_file;
      fflush (gc_debug_file.59);
      <D.18590>:
      <D.18588>:
      <D.18583>:
      <D.18580>:
      <D.18577>:
      _objptr = _objptr + 4;
      <D.17443>:
      if (_objptr < _objptr_end) goto <D.17442>; else goto <D.17444>;
      <D.17444>:
    }
    <D.18543>:
    goto <D.17445>;
    <D.17446>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.63 = (unsigned int) _index;
        D.18592 = _index.63 * 4;
        _objptr = _objptr + D.18592;
        D.18593 = _index + 1;
        _bmap = _bmap >> D.18593;
        D.18594 = *_objptr;
        if (D.18594 != 0B) goto <D.18595>; else goto <D.18596>;
        <D.18595>:
        D.18594 = *_objptr;
        D.18597 = sgen_ptr_in_nursery (D.18594);
        if (D.18597 == 0) goto <D.18598>; else goto <D.18599>;
        <D.18598>:
        D.18594 = *_objptr;
        D.18600 = is_major_or_los_object_marked (D.18594);
        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.18564 = gc_debug_level.60 >= 0;
        D.18565 = (long int) D.18564;
        D.18566 = __builtin_expect (D.18565, 0);
        if (D.18566 != 0) goto <D.18608>; else goto <D.18609>;
        <D.18608>:
        D.18569 = MEM[(struct MonoObject *)start].vtable;
        D.18570 = D.18569->klass;
        D.18571 = D.18570->name;
        D.18569 = MEM[(struct MonoObject *)start].vtable;
        D.18570 = D.18569->klass;
        D.18572 = D.18570->name_space;
        _objptr.64 = (int) _objptr;
        start.62 = (int) start;
        D.18611 = _objptr.64 - start.62;
        D.18594 = *_objptr;
        gc_debug_file.59 = gc_debug_file;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18594, D.18611, start, D.18572, D.18571);
        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;
      }
      goto <D.17452>;
      <D.17451>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.65 = (unsigned int) _index;
        D.18613 = _index.65 * 4;
        _objptr = _objptr + D.18613;
        D.18614 = _index + 1;
        _bmap = _bmap >> D.18614;
        D.18594 = *_objptr;
        if (D.18594 != 0B) goto <D.18615>; else goto <D.18616>;
        <D.18615>:
        D.18594 = *_objptr;
        D.18617 = sgen_ptr_in_nursery (D.18594);
        if (D.18617 == 0) goto <D.18618>; else goto <D.18619>;
        <D.18618>:
        D.18594 = *_objptr;
        D.18620 = is_major_or_los_object_marked (D.18594);
        if (D.18620 == 0) goto <D.18621>; else goto <D.18622>;
        <D.18621>:
        D.18623 = sgen_get_remset ();
        D.18624 = D.18623->find_address_with_cards;
        D.18625 = D.18624 (start, cards, _objptr);
        if (D.18625 == 0) goto <D.18626>; else goto <D.18627>;
        <D.18626>:
        gc_debug_level.60 = gc_debug_level;
        D.18564 = gc_debug_level.60 >= 0;
        D.18565 = (long int) D.18564;
        D.18566 = __builtin_expect (D.18565, 0);
        if (D.18566 != 0) goto <D.18628>; else goto <D.18629>;
        <D.18628>:
        D.18569 = MEM[(struct MonoObject *)start].vtable;
        D.18570 = D.18569->klass;
        D.18571 = D.18570->name;
        D.18569 = MEM[(struct MonoObject *)start].vtable;
        D.18570 = D.18569->klass;
        D.18572 = D.18570->name_space;
        _objptr.64 = (int) _objptr;
        start.62 = (int) start;
        D.18611 = _objptr.64 - start.62;
        D.18594 = *_objptr;
        gc_debug_file.59 = gc_debug_file;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18594, D.18611, start, D.18572, D.18571);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.18629>:
        <D.18627>:
        <D.18622>:
        <D.18619>:
        <D.18616>:
        _objptr = _objptr + 4;
      }
      <D.17452>:
      if (_bmap != 0) goto <D.17451>; else goto <D.17453>;
      <D.17453>:
    }
    goto <D.17445>;
    <D.17454>:
    D.18630 = desc & 4294950912;
    if (D.18630 != 0) goto <D.18631>; else goto <D.18632>;
    <D.18631>:
    {
      int el_size;
      int etype;

      D.18633 = desc >> 3;
      D.18634 = (int) D.18633;
      el_size = D.18634 & 1023;
      desc.66 = (int) desc;
      etype = desc.66 & 49152;
      if (etype == 16384) goto <D.18636>; else goto <D.18637>;
      <D.18636>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.18638 = MEM[(struct MonoArray *)start].max_length;
        el_size.67 = (unsigned int) el_size;
        D.18640 = D.18638 * el_size.67;
        end_refs = p + D.18640;
        goto <D.17460>;
        <D.17459>:
        D.18641 = *p;
        if (D.18641 != 0B) goto <D.18642>; else goto <D.18643>;
        <D.18642>:
        D.18641 = *p;
        D.18644 = sgen_ptr_in_nursery (D.18641);
        if (D.18644 == 0) goto <D.18645>; else goto <D.18646>;
        <D.18645>:
        D.18641 = *p;
        D.18647 = is_major_or_los_object_marked (D.18641);
        if (D.18647 == 0) goto <D.18648>; else goto <D.18649>;
        <D.18648>:
        D.18650 = sgen_get_remset ();
        D.18651 = D.18650->find_address_with_cards;
        D.18652 = D.18651 (start, cards, p);
        if (D.18652 == 0) goto <D.18653>; else goto <D.18654>;
        <D.18653>:
        gc_debug_level.60 = gc_debug_level;
        D.18564 = gc_debug_level.60 >= 0;
        D.18565 = (long int) D.18564;
        D.18566 = __builtin_expect (D.18565, 0);
        if (D.18566 != 0) goto <D.18655>; else goto <D.18656>;
        <D.18655>:
        D.18569 = MEM[(struct MonoObject *)start].vtable;
        D.18570 = D.18569->klass;
        D.18571 = D.18570->name;
        D.18569 = MEM[(struct MonoObject *)start].vtable;
        D.18570 = D.18569->klass;
        D.18572 = D.18570->name_space;
        p.68 = (int) p;
        start.62 = (int) start;
        D.18658 = p.68 - start.62;
        D.18641 = *p;
        gc_debug_file.59 = gc_debug_file;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18641, D.18658, start, D.18572, D.18571);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.18656>:
        <D.18654>:
        <D.18649>:
        <D.18646>:
        <D.18643>:
        p = p + 4;
        <D.17460>:
        if (p < end_refs) goto <D.17459>; else goto <D.17461>;
        <D.17461>:
      }
      goto <D.18659>;
      <D.18637>:
      if (etype == 32768) goto <D.18660>; else goto <D.18661>;
      <D.18660>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.18544 = desc >> 16;
        D.18662 = (int) D.18544;
        offset = D.18662 & 255;
        D.18547 = desc >> 24;
        num_refs = (int) D.18547;
        e_start = start + 16;
        D.18638 = MEM[(struct MonoArray *)start].max_length;
        el_size.67 = (unsigned int) el_size;
        D.18640 = D.18638 * el_size.67;
        e_end = e_start + D.18640;
        goto <D.17472>;
        <D.17471>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.69 = (unsigned int) offset;
          D.18664 = offset.69 * 4;
          p = p + D.18664;
          i = 0;
          goto <D.17469>;
          <D.17468>:
          i.70 = (unsigned int) i;
          D.18666 = i.70 * 4;
          D.18667 = p + D.18666;
          D.18668 = *D.18667;
          if (D.18668 != 0B) goto <D.18669>; else goto <D.18670>;
          <D.18669>:
          i.70 = (unsigned int) i;
          D.18666 = i.70 * 4;
          D.18667 = p + D.18666;
          D.18668 = *D.18667;
          D.18671 = sgen_ptr_in_nursery (D.18668);
          if (D.18671 == 0) goto <D.18672>; else goto <D.18673>;
          <D.18672>:
          i.70 = (unsigned int) i;
          D.18666 = i.70 * 4;
          D.18667 = p + D.18666;
          D.18668 = *D.18667;
          D.18674 = is_major_or_los_object_marked (D.18668);
          if (D.18674 == 0) goto <D.18675>; else goto <D.18676>;
          <D.18675>:
          D.18677 = sgen_get_remset ();
          D.18678 = D.18677->find_address_with_cards;
          i.70 = (unsigned int) i;
          D.18666 = i.70 * 4;
          D.18679 = p + D.18666;
          D.18680 = D.18678 (start, cards, D.18679);
          if (D.18680 == 0) goto <D.18681>; else goto <D.18682>;
          <D.18681>:
          gc_debug_level.60 = gc_debug_level;
          D.18564 = gc_debug_level.60 >= 0;
          D.18565 = (long int) D.18564;
          D.18566 = __builtin_expect (D.18565, 0);
          if (D.18566 != 0) goto <D.18683>; else goto <D.18684>;
          <D.18683>:
          D.18569 = MEM[(struct MonoObject *)start].vtable;
          D.18570 = D.18569->klass;
          D.18571 = D.18570->name;
          D.18569 = MEM[(struct MonoObject *)start].vtable;
          D.18570 = D.18569->klass;
          D.18572 = D.18570->name_space;
          i.70 = (unsigned int) i;
          D.18666 = i.70 * 4;
          D.18679 = p + D.18666;
          D.18685 = (int) D.18679;
          start.62 = (int) start;
          D.18686 = D.18685 - start.62;
          i.70 = (unsigned int) i;
          D.18666 = i.70 * 4;
          D.18667 = p + D.18666;
          D.18668 = *D.18667;
          gc_debug_file.59 = gc_debug_file;
          fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18668, D.18686, start, D.18572, D.18571);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.18684>:
          <D.18682>:
          <D.18676>:
          <D.18673>:
          <D.18670>:
          i = i + 1;
          <D.17469>:
          if (i < num_refs) goto <D.17468>; else goto <D.17470>;
          <D.17470>:
          el_size.71 = (sizetype) el_size;
          e_start = e_start + el_size.71;
        }
        <D.17472>:
        if (e_start < e_end) goto <D.17471>; else goto <D.17473>;
        <D.17473>:
      }
      goto <D.18688>;
      <D.18661>:
      if (etype == 49152) goto <D.18689>; else goto <D.18690>;
      <D.18689>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.18638 = MEM[(struct MonoArray *)start].max_length;
        el_size.67 = (unsigned int) el_size;
        D.18640 = D.18638 * el_size.67;
        e_end = e_start + D.18640;
        goto <D.17482>;
        <D.17481>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17479>;
          <D.17478>:
          D.18691 = _bmap & 1;
          if (D.18691 != 0) goto <D.18692>; else goto <D.18693>;
          <D.18692>:
          D.18694 = *p;
          if (D.18694 != 0B) goto <D.18695>; else goto <D.18696>;
          <D.18695>:
          D.18694 = *p;
          D.18697 = sgen_ptr_in_nursery (D.18694);
          if (D.18697 == 0) goto <D.18698>; else goto <D.18699>;
          <D.18698>:
          D.18694 = *p;
          D.18700 = is_major_or_los_object_marked (D.18694);
          if (D.18700 == 0) goto <D.18701>; else goto <D.18702>;
          <D.18701>:
          D.18703 = sgen_get_remset ();
          D.18704 = D.18703->find_address_with_cards;
          D.18705 = D.18704 (start, cards, p);
          if (D.18705 == 0) goto <D.18706>; else goto <D.18707>;
          <D.18706>:
          gc_debug_level.60 = gc_debug_level;
          D.18564 = gc_debug_level.60 >= 0;
          D.18565 = (long int) D.18564;
          D.18566 = __builtin_expect (D.18565, 0);
          if (D.18566 != 0) goto <D.18708>; else goto <D.18709>;
          <D.18708>:
          D.18569 = MEM[(struct MonoObject *)start].vtable;
          D.18570 = D.18569->klass;
          D.18571 = D.18570->name;
          D.18569 = MEM[(struct MonoObject *)start].vtable;
          D.18570 = D.18569->klass;
          D.18572 = D.18570->name_space;
          p.72 = (int) p;
          start.62 = (int) start;
          D.18711 = p.72 - start.62;
          D.18694 = *p;
          gc_debug_file.59 = gc_debug_file;
          fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18694, D.18711, start, D.18572, D.18571);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.18709>:
          <D.18707>:
          <D.18702>:
          <D.18699>:
          <D.18696>:
          <D.18693>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17479>:
          if (_bmap != 0) goto <D.17478>; else goto <D.17480>;
          <D.17480>:
          el_size.71 = (sizetype) el_size;
          e_start = e_start + el_size.71;
        }
        <D.17482>:
        if (e_start < e_end) goto <D.17481>; else goto <D.17483>;
        <D.17483>:
      }
      <D.18690>:
      <D.18688>:
      <D.18659>:
    }
    <D.18632>:
    goto <D.17445>;
    <D.17484>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17488>;
      <D.17487>:
      D.18712 = _bmap & 1;
      if (D.18712 != 0) goto <D.18713>; else goto <D.18714>;
      <D.18713>:
      D.18715 = *_objptr;
      if (D.18715 != 0B) goto <D.18716>; else goto <D.18717>;
      <D.18716>:
      D.18715 = *_objptr;
      D.18718 = sgen_ptr_in_nursery (D.18715);
      if (D.18718 == 0) goto <D.18719>; else goto <D.18720>;
      <D.18719>:
      D.18715 = *_objptr;
      D.18721 = is_major_or_los_object_marked (D.18715);
      if (D.18721 == 0) goto <D.18722>; else goto <D.18723>;
      <D.18722>:
      D.18724 = sgen_get_remset ();
      D.18725 = D.18724->find_address_with_cards;
      D.18726 = D.18725 (start, cards, _objptr);
      if (D.18726 == 0) goto <D.18727>; else goto <D.18728>;
      <D.18727>:
      gc_debug_level.60 = gc_debug_level;
      D.18564 = gc_debug_level.60 >= 0;
      D.18565 = (long int) D.18564;
      D.18566 = __builtin_expect (D.18565, 0);
      if (D.18566 != 0) goto <D.18729>; else goto <D.18730>;
      <D.18729>:
      D.18569 = MEM[(struct MonoObject *)start].vtable;
      D.18570 = D.18569->klass;
      D.18571 = D.18570->name;
      D.18569 = MEM[(struct MonoObject *)start].vtable;
      D.18570 = D.18569->klass;
      D.18572 = D.18570->name_space;
      _objptr.73 = (int) _objptr;
      start.62 = (int) start;
      D.18732 = _objptr.73 - start.62;
      D.18715 = *_objptr;
      gc_debug_file.59 = gc_debug_file;
      fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18715, D.18732, start, D.18572, D.18571);
      gc_debug_file.59 = gc_debug_file;
      fflush (gc_debug_file.59);
      <D.18730>:
      <D.18728>:
      <D.18723>:
      <D.18720>:
      <D.18717>:
      <D.18714>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17488>:
      if (_bmap != 0) goto <D.17487>; else goto <D.17489>;
      <D.17489>:
    }
    goto <D.17445>;
    <D.17490>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.18733 = *bitmap_data;
      D.18734 = D.18733 + 4294967295;
      bwords = (int) D.18734;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.18735>; else goto <D.18736>;
      <D.18735>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.18737 = myobj->vtable;
        D.18738 = D.18737->klass;
        D.18739 = D.18738->name;
        D.18737 = myobj->vtable;
        D.18738 = D.18737->klass;
        D.18740 = D.18738->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18740, D.18739);
      }
      <D.18736>:
      goto <D.17501>;
      <D.17500>:
      {
        gsize _bmap;

        bitmap_data.74 = bitmap_data;
        bitmap_data = bitmap_data.74 + 4;
        _bmap = *bitmap_data.74;
        _objptr = start_run;
        goto <D.17498>;
        <D.17497>:
        D.18742 = _bmap & 1;
        if (D.18742 != 0) goto <D.18743>; else goto <D.18744>;
        <D.18743>:
        D.18745 = *_objptr;
        if (D.18745 != 0B) goto <D.18746>; else goto <D.18747>;
        <D.18746>:
        D.18745 = *_objptr;
        D.18748 = sgen_ptr_in_nursery (D.18745);
        if (D.18748 == 0) goto <D.18749>; else goto <D.18750>;
        <D.18749>:
        D.18745 = *_objptr;
        D.18751 = is_major_or_los_object_marked (D.18745);
        if (D.18751 == 0) goto <D.18752>; else goto <D.18753>;
        <D.18752>:
        D.18754 = sgen_get_remset ();
        D.18755 = D.18754->find_address_with_cards;
        D.18756 = D.18755 (start, cards, _objptr);
        if (D.18756 == 0) goto <D.18757>; else goto <D.18758>;
        <D.18757>:
        gc_debug_level.60 = gc_debug_level;
        D.18564 = gc_debug_level.60 >= 0;
        D.18565 = (long int) D.18564;
        D.18566 = __builtin_expect (D.18565, 0);
        if (D.18566 != 0) goto <D.18759>; else goto <D.18760>;
        <D.18759>:
        D.18569 = MEM[(struct MonoObject *)start].vtable;
        D.18570 = D.18569->klass;
        D.18571 = D.18570->name;
        D.18569 = MEM[(struct MonoObject *)start].vtable;
        D.18570 = D.18569->klass;
        D.18572 = D.18570->name_space;
        _objptr.75 = (int) _objptr;
        start.62 = (int) start;
        D.18762 = _objptr.75 - start.62;
        D.18745 = *_objptr;
        gc_debug_file.59 = gc_debug_file;
        fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18745, D.18762, start, D.18572, D.18571);
        gc_debug_file.59 = gc_debug_file;
        fflush (gc_debug_file.59);
        <D.18760>:
        <D.18758>:
        <D.18753>:
        <D.18750>:
        <D.18747>:
        <D.18744>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17498>:
        if (_bmap != 0) goto <D.17497>; else goto <D.17499>;
        <D.17499>:
        start_run = start_run + 128;
      }
      <D.17501>:
      bwords.76 = bwords;
      bwords = bwords.76 + -1;
      if (bwords.76 > 0) goto <D.17500>; else goto <D.17502>;
      <D.17502>:
    }
    goto <D.17445>;
    <D.17503>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.18764 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.18764);
      mbitmap_data.77 = mbitmap_data;
      mbitmap_data = mbitmap_data.77 + 4;
      D.18766 = *mbitmap_data.77;
      D.18767 = D.18766 + 4294967295;
      mbwords = (int) D.18767;
      D.18768 = vt->klass;
      el_size = mono_array_element_size (D.18768);
      e_start = start + 16;
      D.18638 = MEM[(struct MonoArray *)start].max_length;
      el_size.78 = (unsigned int) el_size;
      D.18770 = D.18638 * el_size.78;
      e_end = e_start + D.18770;
      if (0 != 0) goto <D.18771>; else goto <D.18772>;
      <D.18771>:
      D.18768 = vt->klass;
      D.18773 = D.18768->name;
      D.18768 = vt->klass;
      D.18774 = D.18768->name_space;
      D.18764 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.18764, D.18774, D.18773);
      <D.18772>:
      goto <D.17521>;
      <D.17520>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.17518>;
        <D.17517>:
        {
          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.17515>;
          <D.17514>:
          D.18776 = _bmap & 1;
          if (D.18776 != 0) goto <D.18777>; else goto <D.18778>;
          <D.18777>:
          D.18779 = *_objptr;
          if (D.18779 != 0B) goto <D.18780>; else goto <D.18781>;
          <D.18780>:
          D.18779 = *_objptr;
          D.18782 = sgen_ptr_in_nursery (D.18779);
          if (D.18782 == 0) goto <D.18783>; else goto <D.18784>;
          <D.18783>:
          D.18779 = *_objptr;
          D.18785 = is_major_or_los_object_marked (D.18779);
          if (D.18785 == 0) goto <D.18786>; else goto <D.18787>;
          <D.18786>:
          D.18788 = sgen_get_remset ();
          D.18789 = D.18788->find_address_with_cards;
          D.18790 = D.18789 (start, cards, _objptr);
          if (D.18790 == 0) goto <D.18791>; else goto <D.18792>;
          <D.18791>:
          gc_debug_level.60 = gc_debug_level;
          D.18564 = gc_debug_level.60 >= 0;
          D.18565 = (long int) D.18564;
          D.18566 = __builtin_expect (D.18565, 0);
          if (D.18566 != 0) goto <D.18793>; else goto <D.18794>;
          <D.18793>:
          D.18569 = MEM[(struct MonoObject *)start].vtable;
          D.18570 = D.18569->klass;
          D.18571 = D.18570->name;
          D.18569 = MEM[(struct MonoObject *)start].vtable;
          D.18570 = D.18569->klass;
          D.18572 = D.18570->name_space;
          _objptr.80 = (int) _objptr;
          start.62 = (int) start;
          D.18796 = _objptr.80 - start.62;
          D.18779 = *_objptr;
          gc_debug_file.59 = gc_debug_file;
          fprintf (gc_debug_file.59, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", D.18779, D.18796, start, D.18572, D.18571);
          gc_debug_file.59 = gc_debug_file;
          fflush (gc_debug_file.59);
          <D.18794>:
          <D.18792>:
          <D.18787>:
          <D.18784>:
          <D.18781>:
          <D.18778>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17515>:
          if (_bmap != 0) goto <D.17514>; else goto <D.17516>;
          <D.17516>:
          _objptr = start_run + 128;
        }
        <D.17518>:
        bwords.81 = bwords;
        bwords = bwords.81 + 4294967295;
        if (bwords.81 != 0) goto <D.17517>; else goto <D.17519>;
        <D.17519>:
        el_size.82 = (sizetype) el_size;
        e_start = e_start + el_size.82;
      }
      <D.17521>:
      if (e_start < e_end) goto <D.17520>; else goto <D.17522>;
      <D.17522>:
    }
    goto <D.17445>;
    <D.17523>:
    goto <D.17445>;
    <D.17524>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17445>:
  }
}


is_major_or_los_object_marked (char * obj)
{
  unsigned int D.18801;
  gboolean D.18804;
  struct SgenMajorCollector * D.18805;
  gboolean (*<T2bea>) (char *) D.18806;

  D.18801 = sgen_safe_object_get_size (obj);
  if (D.18801 > 8000) goto <D.18802>; else goto <D.18803>;
  <D.18802>:
  D.18804 = sgen_los_object_is_pinned (obj);
  return D.18804;
  <D.18803>:
  D.18805 = sgen_get_major_collector ();
  D.18806 = D.18805->is_object_live;
  D.18804 = D.18806 (obj);
  return D.18804;
}


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

  D.18808 = major_collector.iterate_objects;
  D.18808 (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.18809;
  unsigned int D.18810;
  unsigned int D.18811;
  unsigned int D.18812;
  unsigned int D.18815;
  unsigned int D.18816;
  unsigned int D.18817;
  unsigned int D.18818;
  unsigned int D.18819;
  void * D.18820;
  unsigned int D.18823;
  unsigned int D.18824;
  unsigned int D.18827;
  int _objptr.83;
  int start.84;
  int D.18830;
  unsigned int D.18835;
  unsigned int _index.85;
  unsigned int D.18837;
  int D.18838;
  void * D.18839;
  unsigned int D.18842;
  unsigned int D.18843;
  unsigned int D.18846;
  int _objptr.86;
  int D.18848;
  unsigned int _index.87;
  unsigned int D.18850;
  int D.18851;
  unsigned int D.18856;
  unsigned int D.18857;
  unsigned int D.18860;
  int D.18861;
  int desc.88;
  unsigned int D.18865;
  unsigned int el_size.89;
  unsigned int D.18867;
  void * D.18868;
  unsigned int D.18871;
  unsigned int D.18872;
  unsigned int D.18875;
  int p.90;
  int D.18877;
  int D.18881;
  unsigned int offset.91;
  unsigned int D.18883;
  unsigned int i.92;
  unsigned int D.18885;
  void * * D.18886;
  void * D.18887;
  unsigned int D.18890;
  unsigned int D.18891;
  unsigned int D.18894;
  sizetype i.93;
  char * D.18896;
  int D.18897;
  int D.18898;
  sizetype el_size.94;
  unsigned int D.18903;
  void * D.18906;
  unsigned int D.18909;
  unsigned int D.18910;
  unsigned int D.18913;
  int p.95;
  int D.18915;
  unsigned int D.18916;
  void * D.18919;
  unsigned int D.18922;
  unsigned int D.18923;
  unsigned int D.18926;
  int _objptr.96;
  int D.18928;
  unsigned int D.18929;
  unsigned int D.18930;
  struct MonoVTable * D.18933;
  struct MonoClass * D.18934;
  const char * D.18935;
  const char * D.18936;
  gsize * bitmap_data.97;
  unsigned int D.18938;
  void * D.18941;
  unsigned int D.18944;
  unsigned int D.18945;
  unsigned int D.18948;
  int _objptr.98;
  int D.18950;
  int bwords.99;
  unsigned int D.18952;
  gsize * mbitmap_data.100;
  unsigned int D.18954;
  unsigned int D.18955;
  struct MonoClass * D.18956;
  unsigned int el_size.101;
  unsigned int D.18958;
  const char * D.18961;
  const char * D.18962;
  gsize * bitmap_data.102;
  unsigned int D.18964;
  void * D.18967;
  unsigned int D.18970;
  unsigned int D.18971;
  unsigned int D.18974;
  int _objptr.103;
  int D.18976;
  unsigned int bwords.104;
  sizetype el_size.105;

  {
    struct GCVTable * vt;
    mword desc;

    D.18809 = MEM[(mword *)start];
    D.18810 = D.18809 & 4294967292;
    vt = (struct GCVTable *) D.18810;
    desc = vt->desc;
    D.18811 = desc & 7;
    switch (D.18811) <default: <D.17630>, case 1: <D.17535>, case 2: <D.17544>, case 3: <D.17594>, case 4: <D.17554>, case 5: <D.17587>, case 6: <D.17608>, case 7: <D.17629>>
    <D.17535>:
    D.18812 = desc & 4294901760;
    if (D.18812 != 0) goto <D.18813>; else goto <D.18814>;
    <D.18813>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.18815 = desc >> 16;
      D.18816 = D.18815 & 255;
      D.18817 = D.18816 * 4;
      _objptr = _objptr + D.18817;
      D.18818 = desc >> 24;
      D.18819 = D.18818 * 4;
      _objptr_end = _objptr + D.18819;
      D.18820 = *_objptr;
      if (D.18820 != 0B) goto <D.18821>; else goto <D.18822>;
      <D.18821>:
      D.18820 = *_objptr;
      D.18823 = MEM[(mword *)D.18820];
      D.18824 = D.18823 & 4294967292;
      if (D.18824 == 0) goto <D.18825>; else goto <D.18826>;
      <D.18825>:
      D.18827 = sgen_safe_object_get_size (start);
      _objptr.83 = (int) _objptr;
      start.84 = (int) start;
      D.18830 = _objptr.83 - start.84;
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18830, D.18827);
      <D.17538>:
      goto <D.17538>;
      <D.18826>:
      <D.18822>:
      _objptr = _objptr + 4;
      goto <D.17541>;
      <D.17540>:
      D.18820 = *_objptr;
      if (D.18820 != 0B) goto <D.18831>; else goto <D.18832>;
      <D.18831>:
      D.18820 = *_objptr;
      D.18823 = MEM[(mword *)D.18820];
      D.18824 = D.18823 & 4294967292;
      if (D.18824 == 0) goto <D.18833>; else goto <D.18834>;
      <D.18833>:
      D.18835 = sgen_safe_object_get_size (start);
      _objptr.83 = (int) _objptr;
      start.84 = (int) start;
      D.18830 = _objptr.83 - start.84;
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18830, D.18835);
      <D.17539>:
      goto <D.17539>;
      <D.18834>:
      <D.18832>:
      _objptr = _objptr + 4;
      <D.17541>:
      if (_objptr < _objptr_end) goto <D.17540>; else goto <D.17542>;
      <D.17542>:
    }
    <D.18814>:
    goto <D.17543>;
    <D.17544>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.85 = (unsigned int) _index;
        D.18837 = _index.85 * 4;
        _objptr = _objptr + D.18837;
        D.18838 = _index + 1;
        _bmap = _bmap >> D.18838;
        D.18839 = *_objptr;
        if (D.18839 != 0B) goto <D.18840>; else goto <D.18841>;
        <D.18840>:
        D.18839 = *_objptr;
        D.18842 = MEM[(mword *)D.18839];
        D.18843 = D.18842 & 4294967292;
        if (D.18843 == 0) goto <D.18844>; else goto <D.18845>;
        <D.18844>:
        D.18846 = sgen_safe_object_get_size (start);
        _objptr.86 = (int) _objptr;
        start.84 = (int) start;
        D.18848 = _objptr.86 - start.84;
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18848, D.18846);
        <D.17548>:
        goto <D.17548>;
        <D.18845>:
        <D.18841>:
        _objptr = _objptr + 4;
      }
      goto <D.17552>;
      <D.17551>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.87 = (unsigned int) _index;
        D.18850 = _index.87 * 4;
        _objptr = _objptr + D.18850;
        D.18851 = _index + 1;
        _bmap = _bmap >> D.18851;
        D.18839 = *_objptr;
        if (D.18839 != 0B) goto <D.18852>; else goto <D.18853>;
        <D.18852>:
        D.18839 = *_objptr;
        D.18842 = MEM[(mword *)D.18839];
        D.18843 = D.18842 & 4294967292;
        if (D.18843 == 0) goto <D.18854>; else goto <D.18855>;
        <D.18854>:
        D.18856 = sgen_safe_object_get_size (start);
        _objptr.86 = (int) _objptr;
        start.84 = (int) start;
        D.18848 = _objptr.86 - start.84;
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18848, D.18856);
        <D.17550>:
        goto <D.17550>;
        <D.18855>:
        <D.18853>:
        _objptr = _objptr + 4;
      }
      <D.17552>:
      if (_bmap != 0) goto <D.17551>; else goto <D.17553>;
      <D.17553>:
    }
    goto <D.17543>;
    <D.17554>:
    D.18857 = desc & 4294950912;
    if (D.18857 != 0) goto <D.18858>; else goto <D.18859>;
    <D.18858>:
    {
      int el_size;
      int etype;

      D.18860 = desc >> 3;
      D.18861 = (int) D.18860;
      el_size = D.18861 & 1023;
      desc.88 = (int) desc;
      etype = desc.88 & 49152;
      if (etype == 16384) goto <D.18863>; else goto <D.18864>;
      <D.18863>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.18865 = MEM[(struct MonoArray *)start].max_length;
        el_size.89 = (unsigned int) el_size;
        D.18867 = D.18865 * el_size.89;
        end_refs = p + D.18867;
        goto <D.17561>;
        <D.17560>:
        D.18868 = *p;
        if (D.18868 != 0B) goto <D.18869>; else goto <D.18870>;
        <D.18869>:
        D.18868 = *p;
        D.18871 = MEM[(mword *)D.18868];
        D.18872 = D.18871 & 4294967292;
        if (D.18872 == 0) goto <D.18873>; else goto <D.18874>;
        <D.18873>:
        D.18875 = sgen_safe_object_get_size (start);
        p.90 = (int) p;
        start.84 = (int) start;
        D.18877 = p.90 - start.84;
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18877, D.18875);
        <D.17559>:
        goto <D.17559>;
        <D.18874>:
        <D.18870>:
        p = p + 4;
        <D.17561>:
        if (p < end_refs) goto <D.17560>; else goto <D.17562>;
        <D.17562>:
      }
      goto <D.18878>;
      <D.18864>:
      if (etype == 32768) goto <D.18879>; else goto <D.18880>;
      <D.18879>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.18815 = desc >> 16;
        D.18881 = (int) D.18815;
        offset = D.18881 & 255;
        D.18818 = desc >> 24;
        num_refs = (int) D.18818;
        e_start = start + 16;
        D.18865 = MEM[(struct MonoArray *)start].max_length;
        el_size.89 = (unsigned int) el_size;
        D.18867 = D.18865 * el_size.89;
        e_end = e_start + D.18867;
        goto <D.17574>;
        <D.17573>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.91 = (unsigned int) offset;
          D.18883 = offset.91 * 4;
          p = p + D.18883;
          i = 0;
          goto <D.17571>;
          <D.17570>:
          i.92 = (unsigned int) i;
          D.18885 = i.92 * 4;
          D.18886 = p + D.18885;
          D.18887 = *D.18886;
          if (D.18887 != 0B) goto <D.18888>; else goto <D.18889>;
          <D.18888>:
          i.92 = (unsigned int) i;
          D.18885 = i.92 * 4;
          D.18886 = p + D.18885;
          D.18887 = *D.18886;
          D.18890 = MEM[(mword *)D.18887];
          D.18891 = D.18890 & 4294967292;
          if (D.18891 == 0) goto <D.18892>; else goto <D.18893>;
          <D.18892>:
          D.18894 = sgen_safe_object_get_size (start);
          i.93 = (sizetype) i;
          D.18896 = p + i.93;
          D.18897 = (int) D.18896;
          start.84 = (int) start;
          D.18898 = D.18897 - start.84;
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18898, D.18894);
          <D.17569>:
          goto <D.17569>;
          <D.18893>:
          <D.18889>:
          i = i + 1;
          <D.17571>:
          if (i < num_refs) goto <D.17570>; else goto <D.17572>;
          <D.17572>:
          el_size.94 = (sizetype) el_size;
          e_start = e_start + el_size.94;
        }
        <D.17574>:
        if (e_start < e_end) goto <D.17573>; else goto <D.17575>;
        <D.17575>:
      }
      goto <D.18900>;
      <D.18880>:
      if (etype == 49152) goto <D.18901>; else goto <D.18902>;
      <D.18901>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.18865 = MEM[(struct MonoArray *)start].max_length;
        el_size.89 = (unsigned int) el_size;
        D.18867 = D.18865 * el_size.89;
        e_end = e_start + D.18867;
        goto <D.17585>;
        <D.17584>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17582>;
          <D.17581>:
          D.18903 = _bmap & 1;
          if (D.18903 != 0) goto <D.18904>; else goto <D.18905>;
          <D.18904>:
          D.18906 = *p;
          if (D.18906 != 0B) goto <D.18907>; else goto <D.18908>;
          <D.18907>:
          D.18906 = *p;
          D.18909 = MEM[(mword *)D.18906];
          D.18910 = D.18909 & 4294967292;
          if (D.18910 == 0) goto <D.18911>; else goto <D.18912>;
          <D.18911>:
          D.18913 = sgen_safe_object_get_size (start);
          p.95 = (int) p;
          start.84 = (int) start;
          D.18915 = p.95 - start.84;
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18915, D.18913);
          <D.17580>:
          goto <D.17580>;
          <D.18912>:
          <D.18908>:
          <D.18905>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17582>:
          if (_bmap != 0) goto <D.17581>; else goto <D.17583>;
          <D.17583>:
          el_size.94 = (sizetype) el_size;
          e_start = e_start + el_size.94;
        }
        <D.17585>:
        if (e_start < e_end) goto <D.17584>; else goto <D.17586>;
        <D.17586>:
      }
      <D.18902>:
      <D.18900>:
      <D.18878>:
    }
    <D.18859>:
    goto <D.17543>;
    <D.17587>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17592>;
      <D.17591>:
      D.18916 = _bmap & 1;
      if (D.18916 != 0) goto <D.18917>; else goto <D.18918>;
      <D.18917>:
      D.18919 = *_objptr;
      if (D.18919 != 0B) goto <D.18920>; else goto <D.18921>;
      <D.18920>:
      D.18919 = *_objptr;
      D.18922 = MEM[(mword *)D.18919];
      D.18923 = D.18922 & 4294967292;
      if (D.18923 == 0) goto <D.18924>; else goto <D.18925>;
      <D.18924>:
      D.18926 = sgen_safe_object_get_size (start);
      _objptr.96 = (int) _objptr;
      start.84 = (int) start;
      D.18928 = _objptr.96 - start.84;
      monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18928, D.18926);
      <D.17590>:
      goto <D.17590>;
      <D.18925>:
      <D.18921>:
      <D.18918>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17592>:
      if (_bmap != 0) goto <D.17591>; else goto <D.17593>;
      <D.17593>:
    }
    goto <D.17543>;
    <D.17594>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.18929 = *bitmap_data;
      D.18930 = D.18929 + 4294967295;
      bwords = (int) D.18930;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.18931>; else goto <D.18932>;
      <D.18931>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.18933 = myobj->vtable;
        D.18934 = D.18933->klass;
        D.18935 = D.18934->name;
        D.18933 = myobj->vtable;
        D.18934 = D.18933->klass;
        D.18936 = D.18934->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18936, D.18935);
      }
      <D.18932>:
      goto <D.17606>;
      <D.17605>:
      {
        gsize _bmap;

        bitmap_data.97 = bitmap_data;
        bitmap_data = bitmap_data.97 + 4;
        _bmap = *bitmap_data.97;
        _objptr = start_run;
        goto <D.17603>;
        <D.17602>:
        D.18938 = _bmap & 1;
        if (D.18938 != 0) goto <D.18939>; else goto <D.18940>;
        <D.18939>:
        D.18941 = *_objptr;
        if (D.18941 != 0B) goto <D.18942>; else goto <D.18943>;
        <D.18942>:
        D.18941 = *_objptr;
        D.18944 = MEM[(mword *)D.18941];
        D.18945 = D.18944 & 4294967292;
        if (D.18945 == 0) goto <D.18946>; else goto <D.18947>;
        <D.18946>:
        D.18948 = sgen_safe_object_get_size (start);
        _objptr.98 = (int) _objptr;
        start.84 = (int) start;
        D.18950 = _objptr.98 - start.84;
        monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18950, D.18948);
        <D.17601>:
        goto <D.17601>;
        <D.18947>:
        <D.18943>:
        <D.18940>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17603>:
        if (_bmap != 0) goto <D.17602>; else goto <D.17604>;
        <D.17604>:
        start_run = start_run + 128;
      }
      <D.17606>:
      bwords.99 = bwords;
      bwords = bwords.99 + -1;
      if (bwords.99 > 0) goto <D.17605>; else goto <D.17607>;
      <D.17607>:
    }
    goto <D.17543>;
    <D.17608>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.18952 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.18952);
      mbitmap_data.100 = mbitmap_data;
      mbitmap_data = mbitmap_data.100 + 4;
      D.18954 = *mbitmap_data.100;
      D.18955 = D.18954 + 4294967295;
      mbwords = (int) D.18955;
      D.18956 = vt->klass;
      el_size = mono_array_element_size (D.18956);
      e_start = start + 16;
      D.18865 = MEM[(struct MonoArray *)start].max_length;
      el_size.101 = (unsigned int) el_size;
      D.18958 = D.18865 * el_size.101;
      e_end = e_start + D.18958;
      if (0 != 0) goto <D.18959>; else goto <D.18960>;
      <D.18959>:
      D.18956 = vt->klass;
      D.18961 = D.18956->name;
      D.18956 = vt->klass;
      D.18962 = D.18956->name_space;
      D.18952 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.18952, D.18962, D.18961);
      <D.18960>:
      goto <D.17627>;
      <D.17626>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.17624>;
        <D.17623>:
        {
          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.17621>;
          <D.17620>:
          D.18964 = _bmap & 1;
          if (D.18964 != 0) goto <D.18965>; else goto <D.18966>;
          <D.18965>:
          D.18967 = *_objptr;
          if (D.18967 != 0B) goto <D.18968>; else goto <D.18969>;
          <D.18968>:
          D.18967 = *_objptr;
          D.18970 = MEM[(mword *)D.18967];
          D.18971 = D.18970 & 4294967292;
          if (D.18971 == 0) goto <D.18972>; else goto <D.18973>;
          <D.18972>:
          D.18974 = sgen_safe_object_get_size (start);
          _objptr.103 = (int) _objptr;
          start.84 = (int) start;
          D.18976 = _objptr.103 - start.84;
          monoeg_g_log (0B, 4, "Could not load vtable for obj %p slot %d (size %d)", start, D.18976, D.18974);
          <D.17619>:
          goto <D.17619>;
          <D.18973>:
          <D.18969>:
          <D.18966>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17621>:
          if (_bmap != 0) goto <D.17620>; else goto <D.17622>;
          <D.17622>:
          _objptr = start_run + 128;
        }
        <D.17624>:
        bwords.104 = bwords;
        bwords = bwords.104 + 4294967295;
        if (bwords.104 != 0) goto <D.17623>; else goto <D.17625>;
        <D.17625>:
        el_size.105 = (sizetype) el_size;
        e_start = e_start + el_size.105;
      }
      <D.17627>:
      if (e_start < e_end) goto <D.17626>; else goto <D.17628>;
      <D.17628>:
    }
    goto <D.17543>;
    <D.17629>:
    goto <D.17543>;
    <D.17630>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17543>:
  }
}


check_object (char * start)
{
  unsigned int D.18982;
  unsigned int D.18983;
  unsigned int D.18984;
  unsigned int D.18985;
  unsigned int D.18988;
  unsigned int D.18989;
  unsigned int D.18990;
  unsigned int D.18991;
  unsigned int D.18992;
  void * D.18993;
  const char * D.18996;
  _Bool D.18997;
  long int D.18998;
  long int D.18999;
  const char * D.19004;
  _Bool D.19005;
  long int D.19006;
  long int D.19007;
  unsigned int _index.106;
  unsigned int D.19011;
  int D.19012;
  void * D.19013;
  const char * D.19016;
  _Bool D.19017;
  long int D.19018;
  long int D.19019;
  unsigned int _index.107;
  unsigned int D.19023;
  int D.19024;
  const char * D.19027;
  _Bool D.19028;
  long int D.19029;
  long int D.19030;
  unsigned int D.19033;
  unsigned int D.19036;
  int D.19037;
  int desc.108;
  unsigned int D.19041;
  unsigned int el_size.109;
  unsigned int D.19043;
  void * D.19044;
  const char * D.19047;
  _Bool D.19048;
  long int D.19049;
  long int D.19050;
  int D.19056;
  unsigned int offset.110;
  unsigned int D.19058;
  unsigned int i.111;
  unsigned int D.19060;
  void * * D.19061;
  void * D.19062;
  const char * D.19065;
  _Bool D.19066;
  long int D.19067;
  long int D.19068;
  sizetype el_size.112;
  unsigned int D.19075;
  void * D.19078;
  const char * D.19081;
  _Bool D.19082;
  long int D.19083;
  long int D.19084;
  unsigned int D.19087;
  void * D.19090;
  const char * D.19093;
  _Bool D.19094;
  long int D.19095;
  long int D.19096;
  unsigned int D.19099;
  unsigned int D.19100;
  struct MonoVTable * D.19103;
  struct MonoClass * D.19104;
  const char * D.19105;
  const char * D.19106;
  gsize * bitmap_data.113;
  unsigned int D.19108;
  void * D.19111;
  const char * D.19114;
  _Bool D.19115;
  long int D.19116;
  long int D.19117;
  int bwords.114;
  unsigned int D.19121;
  gsize * mbitmap_data.115;
  unsigned int D.19123;
  unsigned int D.19124;
  struct MonoClass * D.19125;
  unsigned int el_size.116;
  unsigned int D.19127;
  const char * D.19130;
  const char * D.19131;
  gsize * bitmap_data.117;
  unsigned int D.19133;
  void * D.19136;
  const char * D.19139;
  _Bool D.19140;
  long int D.19141;
  long int D.19142;
  unsigned int bwords.118;
  sizetype el_size.119;

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

    D.18982 = MEM[(mword *)start];
    D.18983 = D.18982 & 4294967292;
    vt = (struct GCVTable *) D.18983;
    desc = vt->desc;
    D.18984 = desc & 7;
    switch (D.18984) <default: <D.17724>, case 1: <D.17639>, case 2: <D.17646>, case 3: <D.17690>, case 4: <D.17654>, case 5: <D.17684>, case 6: <D.17703>, case 7: <D.17723>>
    <D.17639>:
    D.18985 = desc & 4294901760;
    if (D.18985 != 0) goto <D.18986>; else goto <D.18987>;
    <D.18986>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.18988 = desc >> 16;
      D.18989 = D.18988 & 255;
      D.18990 = D.18989 * 4;
      _objptr = _objptr + D.18990;
      D.18991 = desc >> 24;
      D.18992 = D.18991 * 4;
      _objptr_end = _objptr + 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", 64, "sgen_safe_name (*(_objptr)) != NULL");
      <D.19001>:
      <D.18995>:
      _objptr = _objptr + 4;
      goto <D.17643>;
      <D.17642>:
      D.18993 = *_objptr;
      if (D.18993 != 0B) goto <D.19002>; else goto <D.19003>;
      <D.19002>:
      D.18993 = *_objptr;
      D.19004 = sgen_safe_name (D.18993);
      D.19005 = D.19004 == 0B;
      D.19006 = (long int) D.19005;
      D.19007 = __builtin_expect (D.19006, 0);
      if (D.19007 != 0) goto <D.19008>; else goto <D.19009>;
      <D.19008>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_safe_name (*(_objptr)) != NULL");
      <D.19009>:
      <D.19003>:
      _objptr = _objptr + 4;
      <D.17643>:
      if (_objptr < _objptr_end) goto <D.17642>; else goto <D.17644>;
      <D.17644>:
    }
    <D.18987>:
    goto <D.17645>;
    <D.17646>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.106 = (unsigned int) _index;
        D.19011 = _index.106 * 4;
        _objptr = _objptr + D.19011;
        D.19012 = _index + 1;
        _bmap = _bmap >> D.19012;
        D.19013 = *_objptr;
        if (D.19013 != 0B) goto <D.19014>; else goto <D.19015>;
        <D.19014>:
        D.19013 = *_objptr;
        D.19016 = sgen_safe_name (D.19013);
        D.19017 = D.19016 == 0B;
        D.19018 = (long int) D.19017;
        D.19019 = __builtin_expect (D.19018, 0);
        if (D.19019 != 0) goto <D.19020>; else goto <D.19021>;
        <D.19020>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_safe_name (*(_objptr)) != NULL");
        <D.19021>:
        <D.19015>:
        _objptr = _objptr + 4;
      }
      goto <D.17652>;
      <D.17651>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.107 = (unsigned int) _index;
        D.19023 = _index.107 * 4;
        _objptr = _objptr + D.19023;
        D.19024 = _index + 1;
        _bmap = _bmap >> D.19024;
        D.19013 = *_objptr;
        if (D.19013 != 0B) goto <D.19025>; else goto <D.19026>;
        <D.19025>:
        D.19013 = *_objptr;
        D.19027 = sgen_safe_name (D.19013);
        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", 71, "sgen_safe_name (*(_objptr)) != NULL");
        <D.19032>:
        <D.19026>:
        _objptr = _objptr + 4;
      }
      <D.17652>:
      if (_bmap != 0) goto <D.17651>; else goto <D.17653>;
      <D.17653>:
    }
    goto <D.17645>;
    <D.17654>:
    D.19033 = desc & 4294950912;
    if (D.19033 != 0) goto <D.19034>; else goto <D.19035>;
    <D.19034>:
    {
      int el_size;
      int etype;

      D.19036 = desc >> 3;
      D.19037 = (int) D.19036;
      el_size = D.19037 & 1023;
      desc.108 = (int) desc;
      etype = desc.108 & 49152;
      if (etype == 16384) goto <D.19039>; else goto <D.19040>;
      <D.19039>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.19041 = MEM[(struct MonoArray *)start].max_length;
        el_size.109 = (unsigned int) el_size;
        D.19043 = D.19041 * el_size.109;
        end_refs = p + D.19043;
        goto <D.17660>;
        <D.17659>:
        D.19044 = *p;
        if (D.19044 != 0B) goto <D.19045>; else goto <D.19046>;
        <D.19045>:
        D.19044 = *p;
        D.19047 = sgen_safe_name (D.19044);
        D.19048 = D.19047 == 0B;
        D.19049 = (long int) D.19048;
        D.19050 = __builtin_expect (D.19049, 0);
        if (D.19050 != 0) goto <D.19051>; else goto <D.19052>;
        <D.19051>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p)) != NULL");
        <D.19052>:
        <D.19046>:
        p = p + 4;
        <D.17660>:
        if (p < end_refs) goto <D.17659>; else goto <D.17661>;
        <D.17661>:
      }
      goto <D.19053>;
      <D.19040>:
      if (etype == 32768) goto <D.19054>; else goto <D.19055>;
      <D.19054>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.18988 = desc >> 16;
        D.19056 = (int) D.18988;
        offset = D.19056 & 255;
        D.18991 = desc >> 24;
        num_refs = (int) D.18991;
        e_start = start + 16;
        D.19041 = MEM[(struct MonoArray *)start].max_length;
        el_size.109 = (unsigned int) el_size;
        D.19043 = D.19041 * el_size.109;
        e_end = e_start + D.19043;
        goto <D.17672>;
        <D.17671>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.110 = (unsigned int) offset;
          D.19058 = offset.110 * 4;
          p = p + D.19058;
          i = 0;
          goto <D.17669>;
          <D.17668>:
          i.111 = (unsigned int) i;
          D.19060 = i.111 * 4;
          D.19061 = p + D.19060;
          D.19062 = *D.19061;
          if (D.19062 != 0B) goto <D.19063>; else goto <D.19064>;
          <D.19063>:
          i.111 = (unsigned int) i;
          D.19060 = i.111 * 4;
          D.19061 = p + D.19060;
          D.19062 = *D.19061;
          D.19065 = sgen_safe_name (D.19062);
          D.19066 = D.19065 == 0B;
          D.19067 = (long int) D.19066;
          D.19068 = __builtin_expect (D.19067, 0);
          if (D.19068 != 0) goto <D.19069>; else goto <D.19070>;
          <D.19069>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p + i)) != NULL");
          <D.19070>:
          <D.19064>:
          i = i + 1;
          <D.17669>:
          if (i < num_refs) goto <D.17668>; else goto <D.17670>;
          <D.17670>:
          el_size.112 = (sizetype) el_size;
          e_start = e_start + el_size.112;
        }
        <D.17672>:
        if (e_start < e_end) goto <D.17671>; else goto <D.17673>;
        <D.17673>:
      }
      goto <D.19072>;
      <D.19055>:
      if (etype == 49152) goto <D.19073>; else goto <D.19074>;
      <D.19073>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.19041 = MEM[(struct MonoArray *)start].max_length;
        el_size.109 = (unsigned int) el_size;
        D.19043 = D.19041 * el_size.109;
        e_end = e_start + D.19043;
        goto <D.17682>;
        <D.17681>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17679>;
          <D.17678>:
          D.19075 = _bmap & 1;
          if (D.19075 != 0) goto <D.19076>; else goto <D.19077>;
          <D.19076>:
          D.19078 = *p;
          if (D.19078 != 0B) goto <D.19079>; else goto <D.19080>;
          <D.19079>:
          D.19078 = *p;
          D.19081 = sgen_safe_name (D.19078);
          D.19082 = D.19081 == 0B;
          D.19083 = (long int) D.19082;
          D.19084 = __builtin_expect (D.19083, 0);
          if (D.19084 != 0) goto <D.19085>; else goto <D.19086>;
          <D.19085>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_safe_name (*(p)) != NULL");
          <D.19086>:
          <D.19080>:
          <D.19077>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17679>:
          if (_bmap != 0) goto <D.17678>; else goto <D.17680>;
          <D.17680>:
          el_size.112 = (sizetype) el_size;
          e_start = e_start + el_size.112;
        }
        <D.17682>:
        if (e_start < e_end) goto <D.17681>; else goto <D.17683>;
        <D.17683>:
      }
      <D.19074>:
      <D.19072>:
      <D.19053>:
    }
    <D.19035>:
    goto <D.17645>;
    <D.17684>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17688>;
      <D.17687>:
      D.19087 = _bmap & 1;
      if (D.19087 != 0) goto <D.19088>; else goto <D.19089>;
      <D.19088>:
      D.19090 = *_objptr;
      if (D.19090 != 0B) goto <D.19091>; else goto <D.19092>;
      <D.19091>:
      D.19090 = *_objptr;
      D.19093 = sgen_safe_name (D.19090);
      D.19094 = D.19093 == 0B;
      D.19095 = (long int) D.19094;
      D.19096 = __builtin_expect (D.19095, 0);
      if (D.19096 != 0) goto <D.19097>; else goto <D.19098>;
      <D.19097>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "sgen_safe_name (*(_objptr)) != NULL");
      <D.19098>:
      <D.19092>:
      <D.19089>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17688>:
      if (_bmap != 0) goto <D.17687>; else goto <D.17689>;
      <D.17689>:
    }
    goto <D.17645>;
    <D.17690>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19099 = *bitmap_data;
      D.19100 = D.19099 + 4294967295;
      bwords = (int) D.19100;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.19101>; else goto <D.19102>;
      <D.19101>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19103 = myobj->vtable;
        D.19104 = D.19103->klass;
        D.19105 = D.19104->name;
        D.19103 = myobj->vtable;
        D.19104 = D.19103->klass;
        D.19106 = D.19104->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19106, D.19105);
      }
      <D.19102>:
      goto <D.17701>;
      <D.17700>:
      {
        gsize _bmap;

        bitmap_data.113 = bitmap_data;
        bitmap_data = bitmap_data.113 + 4;
        _bmap = *bitmap_data.113;
        _objptr = start_run;
        goto <D.17698>;
        <D.17697>:
        D.19108 = _bmap & 1;
        if (D.19108 != 0) goto <D.19109>; else goto <D.19110>;
        <D.19109>:
        D.19111 = *_objptr;
        if (D.19111 != 0B) goto <D.19112>; else goto <D.19113>;
        <D.19112>:
        D.19111 = *_objptr;
        D.19114 = sgen_safe_name (D.19111);
        D.19115 = D.19114 == 0B;
        D.19116 = (long int) D.19115;
        D.19117 = __builtin_expect (D.19116, 0);
        if (D.19117 != 0) goto <D.19118>; else goto <D.19119>;
        <D.19118>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "sgen_safe_name (*(_objptr)) != NULL");
        <D.19119>:
        <D.19113>:
        <D.19110>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17698>:
        if (_bmap != 0) goto <D.17697>; else goto <D.17699>;
        <D.17699>:
        start_run = start_run + 128;
      }
      <D.17701>:
      bwords.114 = bwords;
      bwords = bwords.114 + -1;
      if (bwords.114 > 0) goto <D.17700>; else goto <D.17702>;
      <D.17702>:
    }
    goto <D.17645>;
    <D.17703>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19121 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19121);
      mbitmap_data.115 = mbitmap_data;
      mbitmap_data = mbitmap_data.115 + 4;
      D.19123 = *mbitmap_data.115;
      D.19124 = D.19123 + 4294967295;
      mbwords = (int) D.19124;
      D.19125 = vt->klass;
      el_size = mono_array_element_size (D.19125);
      e_start = start + 16;
      D.19041 = MEM[(struct MonoArray *)start].max_length;
      el_size.116 = (unsigned int) el_size;
      D.19127 = D.19041 * el_size.116;
      e_end = e_start + D.19127;
      if (0 != 0) goto <D.19128>; else goto <D.19129>;
      <D.19128>:
      D.19125 = vt->klass;
      D.19130 = D.19125->name;
      D.19125 = vt->klass;
      D.19131 = D.19125->name_space;
      D.19121 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19121, D.19131, D.19130);
      <D.19129>:
      goto <D.17721>;
      <D.17720>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.17718>;
        <D.17717>:
        {
          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.17715>;
          <D.17714>:
          D.19133 = _bmap & 1;
          if (D.19133 != 0) goto <D.19134>; else goto <D.19135>;
          <D.19134>:
          D.19136 = *_objptr;
          if (D.19136 != 0B) goto <D.19137>; else goto <D.19138>;
          <D.19137>:
          D.19136 = *_objptr;
          D.19139 = sgen_safe_name (D.19136);
          D.19140 = D.19139 == 0B;
          D.19141 = (long int) D.19140;
          D.19142 = __builtin_expect (D.19141, 0);
          if (D.19142 != 0) goto <D.19143>; else goto <D.19144>;
          <D.19143>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "sgen_safe_name (*(_objptr)) != NULL");
          <D.19144>:
          <D.19138>:
          <D.19135>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17715>:
          if (_bmap != 0) goto <D.17714>; else goto <D.17716>;
          <D.17716>:
          _objptr = start_run + 128;
        }
        <D.17718>:
        bwords.118 = bwords;
        bwords = bwords.118 + 4294967295;
        if (bwords.118 != 0) goto <D.17717>; else goto <D.17719>;
        <D.17719>:
        el_size.119 = (sizetype) el_size;
        e_start = e_start + el_size.119;
      }
      <D.17721>:
      if (e_start < e_end) goto <D.17720>; else goto <D.17722>;
      <D.17722>:
    }
    goto <D.17645>;
    <D.17723>:
    goto <D.17645>;
    <D.17724>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17645>:
  }
}


sgen_check_whole_heap (gboolean allow_missing_pinned)
{
  void * allow_missing_pinned.120;
  struct GCMemSection * nursery_section.121;
  char * D.19151;
  char * D.19152;
  void (*<T2c44>) (gboolean, gboolean, void (*IterateObjectCallbackFunc) (char *, size_t, void *), void *) D.19153;
  int broken_heap.122;
  _Bool D.19155;
  long int D.19156;
  long int D.19157;

  setup_valid_nursery_objects ();
  broken_heap = 0;
  allow_missing_pinned.120 = (void *) allow_missing_pinned;
  nursery_section.121 = nursery_section;
  D.19151 = nursery_section.121->end_data;
  nursery_section.121 = nursery_section;
  D.19152 = nursery_section.121->data;
  sgen_scan_area_with_callback (D.19152, D.19151, verify_object_pointers_callback, allow_missing_pinned.120, 0);
  D.19153 = major_collector.iterate_objects;
  allow_missing_pinned.120 = (void *) allow_missing_pinned;
  D.19153 (1, 1, verify_object_pointers_callback, allow_missing_pinned.120);
  allow_missing_pinned.120 = (void *) allow_missing_pinned;
  sgen_los_iterate_objects (verify_object_pointers_callback, allow_missing_pinned.120);
  broken_heap.122 = broken_heap;
  D.19155 = broken_heap.122 != 0;
  D.19156 = (long int) D.19155;
  D.19157 = __builtin_expect (D.19156, 0);
  if (D.19157 != 0) goto <D.19158>; else goto <D.19159>;
  <D.19158>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 445, "!broken_heap");
  <D.19159>:
}


verify_object_pointers_callback (char * start, size_t size, void * data)
{
  unsigned int D.19160;
  unsigned int D.19161;
  unsigned int D.19162;
  unsigned int D.19163;
  unsigned int D.19166;
  unsigned int D.19167;
  unsigned int D.19168;
  unsigned int D.19169;
  unsigned int D.19170;
  char * D.19171;
  int D.19174;
  int D.19178;
  void * D.19181;
  int D.19182;
  struct SgenRemeberedSet * D.19187;
  gboolean (*<T2bea>) (char *) D.19188;
  int D.19189;
  int D.19192;
  unsigned int D.19196;
  unsigned int D.19197;
  int D.19200;
  int D.19204;
  int D.19207;
  struct SgenRemeberedSet * D.19212;
  gboolean (*<T2bea>) (char *) D.19213;
  int D.19214;
  int D.19217;
  unsigned int _index.123;
  unsigned int D.19222;
  int D.19223;
  char * D.19224;
  int D.19227;
  int D.19231;
  void * D.19234;
  int D.19235;
  struct SgenRemeberedSet * D.19240;
  gboolean (*<T2bea>) (char *) D.19241;
  int D.19242;
  int D.19245;
  unsigned int D.19249;
  unsigned int D.19250;
  unsigned int _index.124;
  unsigned int D.19252;
  int D.19253;
  int D.19256;
  int D.19260;
  int D.19263;
  struct SgenRemeberedSet * D.19268;
  gboolean (*<T2bea>) (char *) D.19269;
  int D.19270;
  int D.19273;
  unsigned int D.19277;
  unsigned int D.19280;
  int D.19281;
  int desc.125;
  unsigned int D.19285;
  unsigned int el_size.126;
  unsigned int D.19287;
  char * D.19288;
  int D.19291;
  int D.19295;
  void * D.19298;
  int D.19299;
  struct SgenRemeberedSet * D.19304;
  gboolean (*<T2bea>) (char *) D.19305;
  int D.19306;
  int D.19309;
  unsigned int D.19313;
  unsigned int D.19314;
  int D.19318;
  unsigned int offset.127;
  unsigned int D.19320;
  char * D.19321;
  sizetype i.128;
  char * D.19323;
  int D.19326;
  unsigned int i.129;
  unsigned int D.19330;
  char * * D.19331;
  int D.19333;
  void * D.19336;
  void * D.19337;
  int D.19338;
  struct SgenRemeberedSet * D.19343;
  gboolean (*<T2bea>) (char *) D.19344;
  char * D.19345;
  int D.19346;
  void * * D.19349;
  void * D.19350;
  int D.19351;
  unsigned int D.19355;
  unsigned int D.19356;
  sizetype el_size.130;
  unsigned int D.19361;
  char * D.19364;
  int D.19367;
  int D.19371;
  void * D.19374;
  int D.19375;
  struct SgenRemeberedSet * D.19380;
  gboolean (*<T2bea>) (char *) D.19381;
  int D.19382;
  int D.19385;
  unsigned int D.19389;
  unsigned int D.19390;
  unsigned int D.19391;
  char * D.19394;
  int D.19397;
  int D.19401;
  void * D.19404;
  int D.19405;
  struct SgenRemeberedSet * D.19410;
  gboolean (*<T2bea>) (char *) D.19411;
  int D.19412;
  int D.19415;
  unsigned int D.19419;
  unsigned int D.19420;
  unsigned int D.19421;
  unsigned int D.19422;
  struct MonoVTable * D.19425;
  struct MonoClass * D.19426;
  const char * D.19427;
  const char * D.19428;
  gsize * bitmap_data.131;
  unsigned int D.19430;
  char * D.19433;
  int D.19436;
  int D.19440;
  void * D.19443;
  int D.19444;
  struct SgenRemeberedSet * D.19449;
  gboolean (*<T2bea>) (char *) D.19450;
  int D.19451;
  int D.19454;
  unsigned int D.19458;
  unsigned int D.19459;
  int bwords.132;
  unsigned int D.19461;
  gsize * mbitmap_data.133;
  unsigned int D.19463;
  unsigned int D.19464;
  struct MonoClass * D.19465;
  unsigned int el_size.134;
  unsigned int D.19467;
  const char * D.19470;
  const char * D.19471;
  gsize * bitmap_data.135;
  unsigned int D.19473;
  char * D.19476;
  int D.19479;
  int D.19483;
  void * D.19486;
  int D.19487;
  struct SgenRemeberedSet * D.19492;
  gboolean (*<T2bea>) (char *) D.19493;
  int D.19494;
  int D.19497;
  unsigned int D.19501;
  unsigned int D.19502;
  unsigned int bwords.136;
  sizetype el_size.137;
  gboolean allow_missing_pinned;

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

    D.19160 = MEM[(mword *)start];
    D.19161 = D.19160 & 4294967292;
    vt = (struct GCVTable *) D.19161;
    desc = vt->desc;
    D.19162 = desc & 7;
    switch (D.19162) <default: <D.17862>, case 1: <D.17777>, case 2: <D.17784>, case 3: <D.17828>, case 4: <D.17792>, case 5: <D.17822>, case 6: <D.17841>, case 7: <D.17861>>
    <D.17777>:
    D.19163 = desc & 4294901760;
    if (D.19163 != 0) goto <D.19164>; else goto <D.19165>;
    <D.19164>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19166 = desc >> 16;
      D.19167 = D.19166 & 255;
      D.19168 = D.19167 * 4;
      _objptr = _objptr + D.19168;
      D.19169 = desc >> 24;
      D.19170 = D.19169 * 4;
      _objptr_end = _objptr + D.19170;
      D.19171 = MEM[(char * *)_objptr];
      if (D.19171 != 0B) goto <D.19172>; else goto <D.19173>;
      <D.19172>:
      D.19171 = MEM[(char * *)_objptr];
      D.19174 = is_valid_object_pointer (D.19171);
      if (D.19174 == 0) goto <D.19175>; else goto <D.19176>;
      <D.19175>:
      bad_pointer_spew (start, _objptr);
      goto <D.19177>;
      <D.19176>:
      D.19178 = sgen_ptr_in_nursery (start);
      if (D.19178 == 0) goto <D.19179>; else goto <D.19180>;
      <D.19179>:
      D.19181 = *_objptr;
      D.19182 = sgen_ptr_in_nursery (D.19181);
      if (D.19182 != 0) goto <D.19183>; else goto <D.19184>;
      <D.19183>:
      D.19187 = sgen_get_remset ();
      D.19188 = D.19187->find_address;
      D.19189 = D.19188 (_objptr);
      if (D.19189 == 0) goto <D.19190>; else goto <D.19191>;
      <D.19190>:
      D.19181 = *_objptr;
      D.19192 = sgen_cement_lookup (D.19181);
      if (D.19192 == 0) goto <D.19193>; else goto <D.19194>;
      <D.19193>:
      if (allow_missing_pinned == 0) goto <D.19185>; else goto <D.19195>;
      <D.19195>:
      D.19181 = *_objptr;
      D.19196 = MEM[(mword *)D.19181];
      D.19197 = D.19196 & 2;
      if (D.19197 == 0) goto <D.19185>; else goto <D.19186>;
      <D.19185>:
      missing_remset_spew (start, _objptr);
      <D.19186>:
      <D.19194>:
      <D.19191>:
      <D.19184>:
      <D.19180>:
      <D.19177>:
      <D.19173>:
      _objptr = _objptr + 4;
      goto <D.17781>;
      <D.17780>:
      D.19171 = MEM[(char * *)_objptr];
      if (D.19171 != 0B) goto <D.19198>; else goto <D.19199>;
      <D.19198>:
      D.19171 = MEM[(char * *)_objptr];
      D.19200 = is_valid_object_pointer (D.19171);
      if (D.19200 == 0) goto <D.19201>; else goto <D.19202>;
      <D.19201>:
      bad_pointer_spew (start, _objptr);
      goto <D.19203>;
      <D.19202>:
      D.19204 = sgen_ptr_in_nursery (start);
      if (D.19204 == 0) goto <D.19205>; else goto <D.19206>;
      <D.19205>:
      D.19181 = *_objptr;
      D.19207 = sgen_ptr_in_nursery (D.19181);
      if (D.19207 != 0) goto <D.19208>; else goto <D.19209>;
      <D.19208>:
      D.19212 = sgen_get_remset ();
      D.19213 = D.19212->find_address;
      D.19214 = D.19213 (_objptr);
      if (D.19214 == 0) goto <D.19215>; else goto <D.19216>;
      <D.19215>:
      D.19181 = *_objptr;
      D.19217 = sgen_cement_lookup (D.19181);
      if (D.19217 == 0) goto <D.19218>; else goto <D.19219>;
      <D.19218>:
      if (allow_missing_pinned == 0) goto <D.19210>; else goto <D.19220>;
      <D.19220>:
      D.19181 = *_objptr;
      D.19196 = MEM[(mword *)D.19181];
      D.19197 = D.19196 & 2;
      if (D.19197 == 0) goto <D.19210>; else goto <D.19211>;
      <D.19210>:
      missing_remset_spew (start, _objptr);
      <D.19211>:
      <D.19219>:
      <D.19216>:
      <D.19209>:
      <D.19206>:
      <D.19203>:
      <D.19199>:
      _objptr = _objptr + 4;
      <D.17781>:
      if (_objptr < _objptr_end) goto <D.17780>; else goto <D.17782>;
      <D.17782>:
    }
    <D.19165>:
    goto <D.17783>;
    <D.17784>:
    {
      void * * _objptr;
      gsize _bmap;

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

        _index = __builtin_ctz (_bmap);
        _index.123 = (unsigned int) _index;
        D.19222 = _index.123 * 4;
        _objptr = _objptr + D.19222;
        D.19223 = _index + 1;
        _bmap = _bmap >> D.19223;
        D.19224 = MEM[(char * *)_objptr];
        if (D.19224 != 0B) goto <D.19225>; else goto <D.19226>;
        <D.19225>:
        D.19224 = MEM[(char * *)_objptr];
        D.19227 = is_valid_object_pointer (D.19224);
        if (D.19227 == 0) goto <D.19228>; else goto <D.19229>;
        <D.19228>:
        bad_pointer_spew (start, _objptr);
        goto <D.19230>;
        <D.19229>:
        D.19231 = sgen_ptr_in_nursery (start);
        if (D.19231 == 0) goto <D.19232>; else goto <D.19233>;
        <D.19232>:
        D.19234 = *_objptr;
        D.19235 = sgen_ptr_in_nursery (D.19234);
        if (D.19235 != 0) goto <D.19236>; else goto <D.19237>;
        <D.19236>:
        D.19240 = sgen_get_remset ();
        D.19241 = D.19240->find_address;
        D.19242 = D.19241 (_objptr);
        if (D.19242 == 0) goto <D.19243>; else goto <D.19244>;
        <D.19243>:
        D.19234 = *_objptr;
        D.19245 = sgen_cement_lookup (D.19234);
        if (D.19245 == 0) goto <D.19246>; else goto <D.19247>;
        <D.19246>:
        if (allow_missing_pinned == 0) goto <D.19238>; else goto <D.19248>;
        <D.19248>:
        D.19234 = *_objptr;
        D.19249 = MEM[(mword *)D.19234];
        D.19250 = D.19249 & 2;
        if (D.19250 == 0) goto <D.19238>; else goto <D.19239>;
        <D.19238>:
        missing_remset_spew (start, _objptr);
        <D.19239>:
        <D.19247>:
        <D.19244>:
        <D.19237>:
        <D.19233>:
        <D.19230>:
        <D.19226>:
        _objptr = _objptr + 4;
      }
      goto <D.17790>;
      <D.17789>:
      {
        int _index;

        _index = __builtin_ctz (_bmap);
        _index.124 = (unsigned int) _index;
        D.19252 = _index.124 * 4;
        _objptr = _objptr + D.19252;
        D.19253 = _index + 1;
        _bmap = _bmap >> D.19253;
        D.19224 = MEM[(char * *)_objptr];
        if (D.19224 != 0B) goto <D.19254>; else goto <D.19255>;
        <D.19254>:
        D.19224 = MEM[(char * *)_objptr];
        D.19256 = is_valid_object_pointer (D.19224);
        if (D.19256 == 0) goto <D.19257>; else goto <D.19258>;
        <D.19257>:
        bad_pointer_spew (start, _objptr);
        goto <D.19259>;
        <D.19258>:
        D.19260 = sgen_ptr_in_nursery (start);
        if (D.19260 == 0) goto <D.19261>; else goto <D.19262>;
        <D.19261>:
        D.19234 = *_objptr;
        D.19263 = sgen_ptr_in_nursery (D.19234);
        if (D.19263 != 0) goto <D.19264>; else goto <D.19265>;
        <D.19264>:
        D.19268 = sgen_get_remset ();
        D.19269 = D.19268->find_address;
        D.19270 = D.19269 (_objptr);
        if (D.19270 == 0) goto <D.19271>; else goto <D.19272>;
        <D.19271>:
        D.19234 = *_objptr;
        D.19273 = sgen_cement_lookup (D.19234);
        if (D.19273 == 0) goto <D.19274>; else goto <D.19275>;
        <D.19274>:
        if (allow_missing_pinned == 0) goto <D.19266>; else goto <D.19276>;
        <D.19276>:
        D.19234 = *_objptr;
        D.19249 = MEM[(mword *)D.19234];
        D.19250 = D.19249 & 2;
        if (D.19250 == 0) goto <D.19266>; else goto <D.19267>;
        <D.19266>:
        missing_remset_spew (start, _objptr);
        <D.19267>:
        <D.19275>:
        <D.19272>:
        <D.19265>:
        <D.19262>:
        <D.19259>:
        <D.19255>:
        _objptr = _objptr + 4;
      }
      <D.17790>:
      if (_bmap != 0) goto <D.17789>; else goto <D.17791>;
      <D.17791>:
    }
    goto <D.17783>;
    <D.17792>:
    D.19277 = desc & 4294950912;
    if (D.19277 != 0) goto <D.19278>; else goto <D.19279>;
    <D.19278>:
    {
      int el_size;
      int etype;

      D.19280 = desc >> 3;
      D.19281 = (int) D.19280;
      el_size = D.19281 & 1023;
      desc.125 = (int) desc;
      etype = desc.125 & 49152;
      if (etype == 16384) goto <D.19283>; else goto <D.19284>;
      <D.19283>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.19285 = MEM[(struct MonoArray *)start].max_length;
        el_size.126 = (unsigned int) el_size;
        D.19287 = D.19285 * el_size.126;
        end_refs = p + D.19287;
        goto <D.17798>;
        <D.17797>:
        D.19288 = MEM[(char * *)p];
        if (D.19288 != 0B) goto <D.19289>; else goto <D.19290>;
        <D.19289>:
        D.19288 = MEM[(char * *)p];
        D.19291 = is_valid_object_pointer (D.19288);
        if (D.19291 == 0) goto <D.19292>; else goto <D.19293>;
        <D.19292>:
        bad_pointer_spew (start, p);
        goto <D.19294>;
        <D.19293>:
        D.19295 = sgen_ptr_in_nursery (start);
        if (D.19295 == 0) goto <D.19296>; else goto <D.19297>;
        <D.19296>:
        D.19298 = *p;
        D.19299 = sgen_ptr_in_nursery (D.19298);
        if (D.19299 != 0) goto <D.19300>; else goto <D.19301>;
        <D.19300>:
        D.19304 = sgen_get_remset ();
        D.19305 = D.19304->find_address;
        D.19306 = D.19305 (p);
        if (D.19306 == 0) goto <D.19307>; else goto <D.19308>;
        <D.19307>:
        D.19298 = *p;
        D.19309 = sgen_cement_lookup (D.19298);
        if (D.19309 == 0) goto <D.19310>; else goto <D.19311>;
        <D.19310>:
        if (allow_missing_pinned == 0) goto <D.19302>; else goto <D.19312>;
        <D.19312>:
        D.19298 = *p;
        D.19313 = MEM[(mword *)D.19298];
        D.19314 = D.19313 & 2;
        if (D.19314 == 0) goto <D.19302>; else goto <D.19303>;
        <D.19302>:
        missing_remset_spew (start, p);
        <D.19303>:
        <D.19311>:
        <D.19308>:
        <D.19301>:
        <D.19297>:
        <D.19294>:
        <D.19290>:
        p = p + 4;
        <D.17798>:
        if (p < end_refs) goto <D.17797>; else goto <D.17799>;
        <D.17799>:
      }
      goto <D.19315>;
      <D.19284>:
      if (etype == 32768) goto <D.19316>; else goto <D.19317>;
      <D.19316>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19166 = desc >> 16;
        D.19318 = (int) D.19166;
        offset = D.19318 & 255;
        D.19169 = desc >> 24;
        num_refs = (int) D.19169;
        e_start = start + 16;
        D.19285 = MEM[(struct MonoArray *)start].max_length;
        el_size.126 = (unsigned int) el_size;
        D.19287 = D.19285 * el_size.126;
        e_end = e_start + D.19287;
        goto <D.17810>;
        <D.17809>:
        {
          void * * p;
          int i;

          p = e_start;
          offset.127 = (unsigned int) offset;
          D.19320 = offset.127 * 4;
          p = p + D.19320;
          i = 0;
          goto <D.17807>;
          <D.17806>:
          D.19321 = MEM[(char * *)p];
          i.128 = (sizetype) i;
          D.19323 = D.19321 + i.128;
          if (D.19323 != 0B) goto <D.19324>; else goto <D.19325>;
          <D.19324>:
          D.19321 = MEM[(char * *)p];
          i.128 = (sizetype) i;
          D.19323 = D.19321 + i.128;
          D.19326 = is_valid_object_pointer (D.19323);
          if (D.19326 == 0) goto <D.19327>; else goto <D.19328>;
          <D.19327>:
          i.129 = (unsigned int) i;
          D.19330 = i.129 * 4;
          D.19331 = p + D.19330;
          bad_pointer_spew (start, D.19331);
          goto <D.19332>;
          <D.19328>:
          D.19333 = sgen_ptr_in_nursery (start);
          if (D.19333 == 0) goto <D.19334>; else goto <D.19335>;
          <D.19334>:
          D.19336 = *p;
          i.128 = (sizetype) i;
          D.19337 = D.19336 + i.128;
          D.19338 = sgen_ptr_in_nursery (D.19337);
          if (D.19338 != 0) goto <D.19339>; else goto <D.19340>;
          <D.19339>:
          D.19343 = sgen_get_remset ();
          D.19344 = D.19343->find_address;
          i.129 = (unsigned int) i;
          D.19330 = i.129 * 4;
          D.19345 = p + D.19330;
          D.19346 = D.19344 (D.19345);
          if (D.19346 == 0) goto <D.19347>; else goto <D.19348>;
          <D.19347>:
          i.129 = (unsigned int) i;
          D.19330 = i.129 * 4;
          D.19349 = p + D.19330;
          D.19350 = *D.19349;
          D.19351 = sgen_cement_lookup (D.19350);
          if (D.19351 == 0) goto <D.19352>; else goto <D.19353>;
          <D.19352>:
          if (allow_missing_pinned == 0) goto <D.19341>; else goto <D.19354>;
          <D.19354>:
          i.129 = (unsigned int) i;
          D.19330 = i.129 * 4;
          D.19349 = p + D.19330;
          D.19350 = *D.19349;
          D.19355 = MEM[(mword *)D.19350];
          D.19356 = D.19355 & 2;
          if (D.19356 == 0) goto <D.19341>; else goto <D.19342>;
          <D.19341>:
          i.129 = (unsigned int) i;
          D.19330 = i.129 * 4;
          D.19331 = p + D.19330;
          missing_remset_spew (start, D.19331);
          <D.19342>:
          <D.19353>:
          <D.19348>:
          <D.19340>:
          <D.19335>:
          <D.19332>:
          <D.19325>:
          i = i + 1;
          <D.17807>:
          if (i < num_refs) goto <D.17806>; else goto <D.17808>;
          <D.17808>:
          el_size.130 = (sizetype) el_size;
          e_start = e_start + el_size.130;
        }
        <D.17810>:
        if (e_start < e_end) goto <D.17809>; else goto <D.17811>;
        <D.17811>:
      }
      goto <D.19358>;
      <D.19317>:
      if (etype == 49152) goto <D.19359>; else goto <D.19360>;
      <D.19359>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.19285 = MEM[(struct MonoArray *)start].max_length;
        el_size.126 = (unsigned int) el_size;
        D.19287 = D.19285 * el_size.126;
        e_end = e_start + D.19287;
        goto <D.17820>;
        <D.17819>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17817>;
          <D.17816>:
          D.19361 = _bmap & 1;
          if (D.19361 != 0) goto <D.19362>; else goto <D.19363>;
          <D.19362>:
          D.19364 = MEM[(char * *)p];
          if (D.19364 != 0B) goto <D.19365>; else goto <D.19366>;
          <D.19365>:
          D.19364 = MEM[(char * *)p];
          D.19367 = is_valid_object_pointer (D.19364);
          if (D.19367 == 0) goto <D.19368>; else goto <D.19369>;
          <D.19368>:
          bad_pointer_spew (start, p);
          goto <D.19370>;
          <D.19369>:
          D.19371 = sgen_ptr_in_nursery (start);
          if (D.19371 == 0) goto <D.19372>; else goto <D.19373>;
          <D.19372>:
          D.19374 = *p;
          D.19375 = sgen_ptr_in_nursery (D.19374);
          if (D.19375 != 0) goto <D.19376>; else goto <D.19377>;
          <D.19376>:
          D.19380 = sgen_get_remset ();
          D.19381 = D.19380->find_address;
          D.19382 = D.19381 (p);
          if (D.19382 == 0) goto <D.19383>; else goto <D.19384>;
          <D.19383>:
          D.19374 = *p;
          D.19385 = sgen_cement_lookup (D.19374);
          if (D.19385 == 0) goto <D.19386>; else goto <D.19387>;
          <D.19386>:
          if (allow_missing_pinned == 0) goto <D.19378>; else goto <D.19388>;
          <D.19388>:
          D.19374 = *p;
          D.19389 = MEM[(mword *)D.19374];
          D.19390 = D.19389 & 2;
          if (D.19390 == 0) goto <D.19378>; else goto <D.19379>;
          <D.19378>:
          missing_remset_spew (start, p);
          <D.19379>:
          <D.19387>:
          <D.19384>:
          <D.19377>:
          <D.19373>:
          <D.19370>:
          <D.19366>:
          <D.19363>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17817>:
          if (_bmap != 0) goto <D.17816>; else goto <D.17818>;
          <D.17818>:
          el_size.130 = (sizetype) el_size;
          e_start = e_start + el_size.130;
        }
        <D.17820>:
        if (e_start < e_end) goto <D.17819>; else goto <D.17821>;
        <D.17821>:
      }
      <D.19360>:
      <D.19358>:
      <D.19315>:
    }
    <D.19279>:
    goto <D.17783>;
    <D.17822>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17826>;
      <D.17825>:
      D.19391 = _bmap & 1;
      if (D.19391 != 0) goto <D.19392>; else goto <D.19393>;
      <D.19392>:
      D.19394 = MEM[(char * *)_objptr];
      if (D.19394 != 0B) goto <D.19395>; else goto <D.19396>;
      <D.19395>:
      D.19394 = MEM[(char * *)_objptr];
      D.19397 = is_valid_object_pointer (D.19394);
      if (D.19397 == 0) goto <D.19398>; else goto <D.19399>;
      <D.19398>:
      bad_pointer_spew (start, _objptr);
      goto <D.19400>;
      <D.19399>:
      D.19401 = sgen_ptr_in_nursery (start);
      if (D.19401 == 0) goto <D.19402>; else goto <D.19403>;
      <D.19402>:
      D.19404 = *_objptr;
      D.19405 = sgen_ptr_in_nursery (D.19404);
      if (D.19405 != 0) goto <D.19406>; else goto <D.19407>;
      <D.19406>:
      D.19410 = sgen_get_remset ();
      D.19411 = D.19410->find_address;
      D.19412 = D.19411 (_objptr);
      if (D.19412 == 0) goto <D.19413>; else goto <D.19414>;
      <D.19413>:
      D.19404 = *_objptr;
      D.19415 = sgen_cement_lookup (D.19404);
      if (D.19415 == 0) goto <D.19416>; else goto <D.19417>;
      <D.19416>:
      if (allow_missing_pinned == 0) goto <D.19408>; else goto <D.19418>;
      <D.19418>:
      D.19404 = *_objptr;
      D.19419 = MEM[(mword *)D.19404];
      D.19420 = D.19419 & 2;
      if (D.19420 == 0) goto <D.19408>; else goto <D.19409>;
      <D.19408>:
      missing_remset_spew (start, _objptr);
      <D.19409>:
      <D.19417>:
      <D.19414>:
      <D.19407>:
      <D.19403>:
      <D.19400>:
      <D.19396>:
      <D.19393>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17826>:
      if (_bmap != 0) goto <D.17825>; else goto <D.17827>;
      <D.17827>:
    }
    goto <D.17783>;
    <D.17828>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19421 = *bitmap_data;
      D.19422 = D.19421 + 4294967295;
      bwords = (int) D.19422;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.19423>; else goto <D.19424>;
      <D.19423>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19425 = myobj->vtable;
        D.19426 = D.19425->klass;
        D.19427 = D.19426->name;
        D.19425 = myobj->vtable;
        D.19426 = D.19425->klass;
        D.19428 = D.19426->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19428, D.19427);
      }
      <D.19424>:
      goto <D.17839>;
      <D.17838>:
      {
        gsize _bmap;

        bitmap_data.131 = bitmap_data;
        bitmap_data = bitmap_data.131 + 4;
        _bmap = *bitmap_data.131;
        _objptr = start_run;
        goto <D.17836>;
        <D.17835>:
        D.19430 = _bmap & 1;
        if (D.19430 != 0) goto <D.19431>; else goto <D.19432>;
        <D.19431>:
        D.19433 = MEM[(char * *)_objptr];
        if (D.19433 != 0B) goto <D.19434>; else goto <D.19435>;
        <D.19434>:
        D.19433 = MEM[(char * *)_objptr];
        D.19436 = is_valid_object_pointer (D.19433);
        if (D.19436 == 0) goto <D.19437>; else goto <D.19438>;
        <D.19437>:
        bad_pointer_spew (start, _objptr);
        goto <D.19439>;
        <D.19438>:
        D.19440 = sgen_ptr_in_nursery (start);
        if (D.19440 == 0) goto <D.19441>; else goto <D.19442>;
        <D.19441>:
        D.19443 = *_objptr;
        D.19444 = sgen_ptr_in_nursery (D.19443);
        if (D.19444 != 0) goto <D.19445>; else goto <D.19446>;
        <D.19445>:
        D.19449 = sgen_get_remset ();
        D.19450 = D.19449->find_address;
        D.19451 = D.19450 (_objptr);
        if (D.19451 == 0) goto <D.19452>; else goto <D.19453>;
        <D.19452>:
        D.19443 = *_objptr;
        D.19454 = sgen_cement_lookup (D.19443);
        if (D.19454 == 0) goto <D.19455>; else goto <D.19456>;
        <D.19455>:
        if (allow_missing_pinned == 0) goto <D.19447>; else goto <D.19457>;
        <D.19457>:
        D.19443 = *_objptr;
        D.19458 = MEM[(mword *)D.19443];
        D.19459 = D.19458 & 2;
        if (D.19459 == 0) goto <D.19447>; else goto <D.19448>;
        <D.19447>:
        missing_remset_spew (start, _objptr);
        <D.19448>:
        <D.19456>:
        <D.19453>:
        <D.19446>:
        <D.19442>:
        <D.19439>:
        <D.19435>:
        <D.19432>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17836>:
        if (_bmap != 0) goto <D.17835>; else goto <D.17837>;
        <D.17837>:
        start_run = start_run + 128;
      }
      <D.17839>:
      bwords.132 = bwords;
      bwords = bwords.132 + -1;
      if (bwords.132 > 0) goto <D.17838>; else goto <D.17840>;
      <D.17840>:
    }
    goto <D.17783>;
    <D.17841>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.19461 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.19461);
      mbitmap_data.133 = mbitmap_data;
      mbitmap_data = mbitmap_data.133 + 4;
      D.19463 = *mbitmap_data.133;
      D.19464 = D.19463 + 4294967295;
      mbwords = (int) D.19464;
      D.19465 = vt->klass;
      el_size = mono_array_element_size (D.19465);
      e_start = start + 16;
      D.19285 = MEM[(struct MonoArray *)start].max_length;
      el_size.134 = (unsigned int) el_size;
      D.19467 = D.19285 * el_size.134;
      e_end = e_start + D.19467;
      if (0 != 0) goto <D.19468>; else goto <D.19469>;
      <D.19468>:
      D.19465 = vt->klass;
      D.19470 = D.19465->name;
      D.19465 = vt->klass;
      D.19471 = D.19465->name_space;
      D.19461 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.19461, D.19471, D.19470);
      <D.19469>:
      goto <D.17859>;
      <D.17858>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.17856>;
        <D.17855>:
        {
          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.17853>;
          <D.17852>:
          D.19473 = _bmap & 1;
          if (D.19473 != 0) goto <D.19474>; else goto <D.19475>;
          <D.19474>:
          D.19476 = MEM[(char * *)_objptr];
          if (D.19476 != 0B) goto <D.19477>; else goto <D.19478>;
          <D.19477>:
          D.19476 = MEM[(char * *)_objptr];
          D.19479 = is_valid_object_pointer (D.19476);
          if (D.19479 == 0) goto <D.19480>; else goto <D.19481>;
          <D.19480>:
          bad_pointer_spew (start, _objptr);
          goto <D.19482>;
          <D.19481>:
          D.19483 = sgen_ptr_in_nursery (start);
          if (D.19483 == 0) goto <D.19484>; else goto <D.19485>;
          <D.19484>:
          D.19486 = *_objptr;
          D.19487 = sgen_ptr_in_nursery (D.19486);
          if (D.19487 != 0) goto <D.19488>; else goto <D.19489>;
          <D.19488>:
          D.19492 = sgen_get_remset ();
          D.19493 = D.19492->find_address;
          D.19494 = D.19493 (_objptr);
          if (D.19494 == 0) goto <D.19495>; else goto <D.19496>;
          <D.19495>:
          D.19486 = *_objptr;
          D.19497 = sgen_cement_lookup (D.19486);
          if (D.19497 == 0) goto <D.19498>; else goto <D.19499>;
          <D.19498>:
          if (allow_missing_pinned == 0) goto <D.19490>; else goto <D.19500>;
          <D.19500>:
          D.19486 = *_objptr;
          D.19501 = MEM[(mword *)D.19486];
          D.19502 = D.19501 & 2;
          if (D.19502 == 0) goto <D.19490>; else goto <D.19491>;
          <D.19490>:
          missing_remset_spew (start, _objptr);
          <D.19491>:
          <D.19499>:
          <D.19496>:
          <D.19489>:
          <D.19485>:
          <D.19482>:
          <D.19478>:
          <D.19475>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17853>:
          if (_bmap != 0) goto <D.17852>; else goto <D.17854>;
          <D.17854>:
          _objptr = start_run + 128;
        }
        <D.17856>:
        bwords.136 = bwords;
        bwords = bwords.136 + 4294967295;
        if (bwords.136 != 0) goto <D.17855>; else goto <D.17857>;
        <D.17857>:
        el_size.137 = (sizetype) el_size;
        e_start = e_start + el_size.137;
      }
      <D.17859>:
      if (e_start < e_end) goto <D.17858>; else goto <D.17860>;
      <D.17860>:
    }
    goto <D.17783>;
    <D.17861>:
    goto <D.17783>;
    <D.17862>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17783>:
  }
}


is_valid_object_pointer (char * object)
{
  int D.19506;
  gboolean D.19509;
  int D.19510;
  gboolean (*<T2bea>) (char *) D.19513;
  int D.19514;

  D.19506 = sgen_ptr_in_nursery (object);
  if (D.19506 != 0) goto <D.19507>; else goto <D.19508>;
  <D.19507>:
  D.19509 = find_object_in_nursery_dump (object);
  return D.19509;
  <D.19508>:
  D.19510 = sgen_los_is_valid_object (object);
  if (D.19510 != 0) goto <D.19511>; else goto <D.19512>;
  <D.19511>:
  D.19509 = 1;
  return D.19509;
  <D.19512>:
  D.19513 = major_collector.is_valid_object;
  D.19514 = D.19513 (object);
  if (D.19514 != 0) goto <D.19515>; else goto <D.19516>;
  <D.19515>:
  D.19509 = 1;
  return D.19509;
  <D.19516>:
  D.19509 = 0;
  return D.19509;
}


find_object_in_nursery_dump (char * object)
{
  int D.19518;
  int D.19519;
  char * * valid_nursery_objects.138;
  unsigned int middle.139;
  unsigned int D.19522;
  char * * D.19523;
  char * D.19524;
  gboolean D.19527;
  _Bool D.19531;
  long int D.19532;
  long int D.19533;
  int first;
  int last;

  first = 0;
  last = valid_nursery_object_count;
  goto <D.17743>;
  <D.17742>:
  {
    int middle;

    D.19518 = last - first;
    D.19519 = D.19518 >> 1;
    middle = D.19519 + first;
    valid_nursery_objects.138 = valid_nursery_objects;
    middle.139 = (unsigned int) middle;
    D.19522 = middle.139 * 4;
    D.19523 = valid_nursery_objects.138 + D.19522;
    D.19524 = *D.19523;
    if (D.19524 == object) goto <D.19525>; else goto <D.19526>;
    <D.19525>:
    D.19527 = 1;
    return D.19527;
    <D.19526>:
    valid_nursery_objects.138 = valid_nursery_objects;
    middle.139 = (unsigned int) middle;
    D.19522 = middle.139 * 4;
    D.19523 = valid_nursery_objects.138 + D.19522;
    D.19524 = *D.19523;
    if (D.19524 > object) goto <D.19528>; else goto <D.19529>;
    <D.19528>:
    last = middle;
    goto <D.19530>;
    <D.19529>:
    first = middle + 1;
    <D.19530>:
  }
  <D.17743>:
  if (first < last) goto <D.17742>; else goto <D.17744>;
  <D.17744>:
  D.19531 = first != last;
  D.19532 = (long int) D.19531;
  D.19533 = __builtin_expect (D.19532, 0);
  if (D.19533 != 0) goto <D.19534>; else goto <D.19535>;
  <D.19534>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 337, "first == last");
  <D.19535>:
  D.19527 = 0;
  return D.19527;
}


bad_pointer_spew (char * obj, char * * slot)
{
  unsigned int D.19537;
  unsigned int D.19538;
  int gc_debug_level.140;
  _Bool D.19540;
  long int D.19541;
  long int D.19542;
  struct MonoClass * D.19545;
  const char * D.19546;
  const char * D.19547;
  int slot.141;
  int obj.142;
  int D.19550;
  struct FILE * gc_debug_file.143;
  char * ptr;
  struct MonoVTable * vtable;

  ptr = *slot;
  D.19537 = MEM[(mword *)obj];
  D.19538 = D.19537 & 4294967292;
  vtable = (struct MonoVTable *) D.19538;
  gc_debug_level.140 = gc_debug_level;
  D.19540 = gc_debug_level.140 >= 0;
  D.19541 = (long int) D.19540;
  D.19542 = __builtin_expect (D.19541, 0);
  if (D.19542 != 0) goto <D.19543>; else goto <D.19544>;
  <D.19543>:
  D.19545 = vtable->klass;
  D.19546 = D.19545->name;
  D.19545 = vtable->klass;
  D.19547 = D.19545->name_space;
  slot.141 = (int) slot;
  obj.142 = (int) obj;
  D.19550 = slot.141 - obj.142;
  gc_debug_file.143 = gc_debug_file;
  fprintf (gc_debug_file.143, "Invalid object pointer %p at offset %td in object %p (%s.%s):\n", ptr, D.19550, obj, D.19547, D.19546);
  gc_debug_file.143 = gc_debug_file;
  fflush (gc_debug_file.143);
  <D.19544>:
  describe_pointer (ptr, 0);
  broken_heap = 1;
}


missing_remset_spew (char * obj, char * * slot)
{
  unsigned int D.19552;
  unsigned int D.19553;
  int gc_debug_level.144;
  _Bool D.19555;
  long int D.19556;
  long int D.19557;
  struct MonoClass * D.19560;
  const char * D.19561;
  const char * D.19562;
  int slot.145;
  int obj.146;
  int D.19565;
  struct FILE * gc_debug_file.147;
  char * ptr;
  struct MonoVTable * vtable;

  ptr = *slot;
  D.19552 = MEM[(mword *)obj];
  D.19553 = D.19552 & 4294967292;
  vtable = (struct MonoVTable *) D.19553;
  gc_debug_level.144 = gc_debug_level;
  D.19555 = gc_debug_level.144 >= 0;
  D.19556 = (long int) D.19555;
  D.19557 = __builtin_expect (D.19556, 0);
  if (D.19557 != 0) goto <D.19558>; else goto <D.19559>;
  <D.19558>:
  D.19560 = vtable->klass;
  D.19561 = D.19560->name;
  D.19560 = vtable->klass;
  D.19562 = D.19560->name_space;
  slot.145 = (int) slot;
  obj.146 = (int) obj;
  D.19565 = slot.145 - obj.146;
  gc_debug_file.147 = gc_debug_file;
  fprintf (gc_debug_file.147, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", ptr, D.19565, obj, D.19562, D.19561);
  gc_debug_file.147 = gc_debug_file;
  fflush (gc_debug_file.147);
  <D.19559>:
  broken_heap = 1;
}


sgen_check_objref (char * obj)
{
  int D.19567;
  _Bool D.19568;
  long int D.19569;
  long int D.19570;

  D.19567 = ptr_in_heap (obj);
  D.19568 = D.19567 == 0;
  D.19569 = (long int) D.19568;
  D.19570 = __builtin_expect (D.19569, 0);
  if (D.19570 != 0) goto <D.19571>; else goto <D.19572>;
  <D.19571>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 469, "ptr_in_heap (obj)");
  <D.19572>:
}


ptr_in_heap (char * object)
{
  int D.19573;
  gboolean D.19576;
  int D.19577;
  gboolean (*<T2bea>) (char *) D.19580;
  int D.19581;

  D.19573 = sgen_ptr_in_nursery (object);
  if (D.19573 != 0) goto <D.19574>; else goto <D.19575>;
  <D.19574>:
  D.19576 = 1;
  return D.19576;
  <D.19575>:
  D.19577 = sgen_los_is_valid_object (object);
  if (D.19577 != 0) goto <D.19578>; else goto <D.19579>;
  <D.19578>:
  D.19576 = 1;
  return D.19576;
  <D.19579>:
  D.19580 = major_collector.is_valid_object;
  D.19581 = D.19580 (object);
  if (D.19581 != 0) goto <D.19582>; else goto <D.19583>;
  <D.19582>:
  D.19576 = 1;
  return D.19576;
  <D.19583>:
  D.19576 = 0;
  return D.19576;
}


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

  setup_valid_nursery_objects ();
  D.19585 = major_collector.iterate_objects;
  D.19585 (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.19588;
  gboolean (*<T2bea>) (char *) D.19592;
  int D.19593;
  unsigned int D.19596;
  unsigned int D.19597;
  unsigned int D.19598;
  unsigned int D.19599;
  unsigned int D.19602;
  unsigned int D.19603;
  unsigned int D.19604;
  unsigned int D.19605;
  unsigned int D.19606;
  int D.19609;
  _Bool D.19610;
  long int D.19611;
  long int D.19612;
  int D.19615;
  unsigned int D.19618;
  unsigned int D.19619;
  _Bool D.19620;
  long int D.19621;
  long int D.19622;
  int D.19626;
  int D.19629;
  _Bool D.19630;
  long int D.19631;
  long int D.19632;
  gboolean (*<T2bea>) (char *) D.19636;
  int D.19637;
  int D.19640;
  _Bool D.19641;
  long int D.19642;
  long int D.19643;
  int D.19649;
  _Bool D.19650;
  long int D.19651;
  long int D.19652;
  int D.19655;
  unsigned int D.19658;
  unsigned int D.19659;
  _Bool D.19660;
  long int D.19661;
  long int D.19662;
  int D.19666;
  int D.19669;
  _Bool D.19670;
  long int D.19671;
  long int D.19672;
  int D.19676;
  int D.19679;
  _Bool D.19680;
  long int D.19681;
  long int D.19682;
  unsigned int _index.148;
  unsigned int D.19687;
  int D.19688;
  int D.19691;
  _Bool D.19692;
  long int D.19693;
  long int D.19694;
  int D.19697;
  unsigned int D.19700;
  unsigned int D.19701;
  _Bool D.19702;
  long int D.19703;
  long int D.19704;
  int D.19708;
  int D.19711;
  _Bool D.19712;
  long int D.19713;
  long int D.19714;
  int D.19718;
  int D.19721;
  _Bool D.19722;
  long int D.19723;
  long int D.19724;
  unsigned int _index.149;
  unsigned int D.19729;
  int D.19730;
  int D.19733;
  _Bool D.19734;
  long int D.19735;
  long int D.19736;
  int D.19739;
  unsigned int D.19742;
  unsigned int D.19743;
  _Bool D.19744;
  long int D.19745;
  long int D.19746;
  int D.19750;
  int D.19753;
  _Bool D.19754;
  long int D.19755;
  long int D.19756;
  int D.19760;
  int D.19763;
  _Bool D.19764;
  long int D.19765;
  long int D.19766;
  unsigned int D.19770;
  unsigned int D.19773;
  int D.19774;
  int desc.150;
  unsigned int D.19778;
  unsigned int el_size.151;
  unsigned int D.19780;
  int D.19783;
  _Bool D.19784;
  long int D.19785;
  long int D.19786;
  int D.19789;
  unsigned int D.19792;
  unsigned int D.19793;
  _Bool D.19794;
  long int D.19795;
  long int D.19796;
  int D.19800;
  int D.19803;
  _Bool D.19804;
  long int D.19805;
  long int D.19806;
  int D.19810;
  int D.19813;
  _Bool D.19814;
  long int D.19815;
  long int D.19816;
  int D.19823;
  unsigned int offset.152;
  unsigned int D.19825;
  char * D.19826;
  sizetype i.153;
  int D.19830;
  _Bool D.19831;
  long int D.19832;
  long int D.19833;
  int D.19836;
  unsigned int D.19839;
  unsigned int D.19840;
  _Bool D.19841;
  long int D.19842;
  long int D.19843;
  int D.19847;
  int D.19850;
  _Bool D.19851;
  long int D.19852;
  long int D.19853;
  int D.19857;
  int D.19860;
  _Bool D.19861;
  long int D.19862;
  long int D.19863;
  sizetype el_size.154;
  unsigned int D.19871;
  int D.19876;
  _Bool D.19877;
  long int D.19878;
  long int D.19879;
  int D.19882;
  unsigned int D.19885;
  unsigned int D.19886;
  _Bool D.19887;
  long int D.19888;
  long int D.19889;
  int D.19893;
  int D.19896;
  _Bool D.19897;
  long int D.19898;
  long int D.19899;
  int D.19903;
  int D.19906;
  _Bool D.19907;
  long int D.19908;
  long int D.19909;
  unsigned int D.19913;
  int D.19918;
  _Bool D.19919;
  long int D.19920;
  long int D.19921;
  int D.19924;
  unsigned int D.19927;
  unsigned int D.19928;
  _Bool D.19929;
  long int D.19930;
  long int D.19931;
  int D.19935;
  int D.19938;
  _Bool D.19939;
  long int D.19940;
  long int D.19941;
  int D.19945;
  int D.19948;
  _Bool D.19949;
  long int D.19950;
  long int D.19951;
  unsigned int D.19955;
  unsigned int D.19956;
  struct MonoVTable * D.19959;
  struct MonoClass * D.19960;
  const char * D.19961;
  const char * D.19962;
  gsize * bitmap_data.155;
  unsigned int D.19964;
  int D.19969;
  _Bool D.19970;
  long int D.19971;
  long int D.19972;
  int D.19975;
  unsigned int D.19978;
  unsigned int D.19979;
  _Bool D.19980;
  long int D.19981;
  long int D.19982;
  int D.19986;
  int D.19989;
  _Bool D.19990;
  long int D.19991;
  long int D.19992;
  int D.19996;
  int D.19999;
  _Bool D.20000;
  long int D.20001;
  long int D.20002;
  int bwords.156;
  unsigned int D.20007;
  gsize * mbitmap_data.157;
  unsigned int D.20009;
  unsigned int D.20010;
  struct MonoClass * D.20011;
  unsigned int el_size.158;
  unsigned int D.20013;
  const char * D.20016;
  const char * D.20017;
  gsize * bitmap_data.159;
  unsigned int D.20019;
  int D.20024;
  _Bool D.20025;
  long int D.20026;
  long int D.20027;
  int D.20030;
  unsigned int D.20033;
  unsigned int D.20034;
  _Bool D.20035;
  long int D.20036;
  long int D.20037;
  int D.20041;
  int D.20044;
  _Bool D.20045;
  long int D.20046;
  long int D.20047;
  int D.20051;
  int D.20054;
  _Bool D.20055;
  long int D.20056;
  long int D.20057;
  unsigned int bwords.160;
  sizetype el_size.161;
  gboolean is_los;

  is_los = (gboolean) dummy;
  if (is_los != 0) goto <D.19586>; else goto <D.19587>;
  <D.19586>:
  D.19588 = sgen_los_object_is_pinned (start);
  if (D.19588 == 0) goto <D.19589>; else goto <D.19590>;
  <D.19589>:
  return;
  <D.19590>:
  goto <D.19591>;
  <D.19587>:
  D.19592 = major_collector.is_object_live;
  D.19593 = D.19592 (start);
  if (D.19593 == 0) goto <D.19594>; else goto <D.19595>;
  <D.19594>:
  return;
  <D.19595>:
  <D.19591>:
  {
    struct GCVTable * vt;
    mword desc;

    D.19596 = MEM[(mword *)start];
    D.19597 = D.19596 & 4294967292;
    vt = (struct GCVTable *) D.19597;
    desc = vt->desc;
    D.19598 = desc & 7;
    switch (D.19598) <default: <D.18017>, case 1: <D.17922>, case 2: <D.17931>, case 3: <D.17981>, case 4: <D.17941>, case 5: <D.17974>, case 6: <D.17995>, case 7: <D.18016>>
    <D.17922>:
    D.19599 = desc & 4294901760;
    if (D.19599 != 0) goto <D.19600>; else goto <D.19601>;
    <D.19600>:
    {
      void * * _objptr_end;
      void * * _objptr;

      _objptr = start;
      D.19602 = desc >> 16;
      D.19603 = D.19602 & 255;
      D.19604 = D.19603 * 4;
      _objptr = _objptr + D.19604;
      D.19605 = desc >> 24;
      D.19606 = D.19605 * 4;
      _objptr_end = _objptr + D.19606;
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.19607>; else goto <D.19608>;
        <D.19607>:
        D.19609 = is_valid_object_pointer (__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, "is_valid_object_pointer (__target)");
        <D.19614>:
        D.19615 = sgen_ptr_in_nursery (__target);
        if (D.19615 != 0) goto <D.19616>; else goto <D.19617>;
        <D.19616>:
        D.19618 = MEM[(mword *)__target];
        D.19619 = D.19618 & 2;
        D.19620 = D.19619 == 0;
        D.19621 = (long int) D.19620;
        D.19622 = __builtin_expect (D.19621, 0);
        if (D.19622 != 0) goto <D.19623>; else goto <D.19624>;
        <D.19623>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.19624>:
        goto <D.19625>;
        <D.19617>:
        D.19626 = sgen_los_is_valid_object (__target);
        if (D.19626 != 0) goto <D.19627>; else goto <D.19628>;
        <D.19627>:
        D.19629 = sgen_los_object_is_pinned (__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, "sgen_los_object_is_pinned (__target)");
        <D.19634>:
        goto <D.19635>;
        <D.19628>:
        D.19636 = major_collector.is_valid_object;
        D.19637 = D.19636 (__target);
        if (D.19637 != 0) goto <D.19638>; else goto <D.19639>;
        <D.19638>:
        D.19592 = major_collector.is_object_live;
        D.19640 = D.19592 (__target);
        D.19641 = D.19640 == 0;
        D.19642 = (long int) D.19641;
        D.19643 = __builtin_expect (D.19642, 0);
        if (D.19643 != 0) goto <D.19644>; else goto <D.19645>;
        <D.19644>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "major_collector.is_object_live (__target)");
        <D.19645>:
        goto <D.19646>;
        <D.19639>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 64);
        <D.19646>:
        <D.19635>:
        <D.19625>:
        <D.19608>:
      }
      _objptr = _objptr + 4;
      goto <D.17928>;
      <D.17927>:
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.19647>; else goto <D.19648>;
        <D.19647>:
        D.19649 = is_valid_object_pointer (__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, "is_valid_object_pointer (__target)");
        <D.19654>:
        D.19655 = sgen_ptr_in_nursery (__target);
        if (D.19655 != 0) goto <D.19656>; else goto <D.19657>;
        <D.19656>:
        D.19658 = MEM[(mword *)__target];
        D.19659 = D.19658 & 2;
        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, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.19664>:
        goto <D.19665>;
        <D.19657>:
        D.19666 = sgen_los_is_valid_object (__target);
        if (D.19666 != 0) goto <D.19667>; else goto <D.19668>;
        <D.19667>:
        D.19669 = sgen_los_object_is_pinned (__target);
        D.19670 = D.19669 == 0;
        D.19671 = (long int) D.19670;
        D.19672 = __builtin_expect (D.19671, 0);
        if (D.19672 != 0) goto <D.19673>; else goto <D.19674>;
        <D.19673>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "sgen_los_object_is_pinned (__target)");
        <D.19674>:
        goto <D.19675>;
        <D.19668>:
        D.19636 = major_collector.is_valid_object;
        D.19676 = D.19636 (__target);
        if (D.19676 != 0) goto <D.19677>; else goto <D.19678>;
        <D.19677>:
        D.19592 = major_collector.is_object_live;
        D.19679 = D.19592 (__target);
        D.19680 = D.19679 == 0;
        D.19681 = (long int) D.19680;
        D.19682 = __builtin_expect (D.19681, 0);
        if (D.19682 != 0) goto <D.19683>; else goto <D.19684>;
        <D.19683>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 64, "major_collector.is_object_live (__target)");
        <D.19684>:
        goto <D.19685>;
        <D.19678>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 64);
        <D.19685>:
        <D.19675>:
        <D.19665>:
        <D.19648>:
      }
      _objptr = _objptr + 4;
      <D.17928>:
      if (_objptr < _objptr_end) goto <D.17927>; else goto <D.17929>;
      <D.17929>:
    }
    <D.19601>:
    goto <D.17930>;
    <D.17931>:
    {
      void * * _objptr;
      gsize _bmap;

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

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

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.19689>; else goto <D.19690>;
          <D.19689>:
          D.19691 = is_valid_object_pointer (__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, "is_valid_object_pointer (__target)");
          <D.19696>:
          D.19697 = sgen_ptr_in_nursery (__target);
          if (D.19697 != 0) goto <D.19698>; else goto <D.19699>;
          <D.19698>:
          D.19700 = MEM[(mword *)__target];
          D.19701 = D.19700 & 2;
          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, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.19706>:
          goto <D.19707>;
          <D.19699>:
          D.19708 = sgen_los_is_valid_object (__target);
          if (D.19708 != 0) goto <D.19709>; else goto <D.19710>;
          <D.19709>:
          D.19711 = sgen_los_object_is_pinned (__target);
          D.19712 = D.19711 == 0;
          D.19713 = (long int) D.19712;
          D.19714 = __builtin_expect (D.19713, 0);
          if (D.19714 != 0) goto <D.19715>; else goto <D.19716>;
          <D.19715>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_los_object_is_pinned (__target)");
          <D.19716>:
          goto <D.19717>;
          <D.19710>:
          D.19636 = major_collector.is_valid_object;
          D.19718 = D.19636 (__target);
          if (D.19718 != 0) goto <D.19719>; else goto <D.19720>;
          <D.19719>:
          D.19592 = major_collector.is_object_live;
          D.19721 = D.19592 (__target);
          D.19722 = D.19721 == 0;
          D.19723 = (long int) D.19722;
          D.19724 = __builtin_expect (D.19723, 0);
          if (D.19724 != 0) goto <D.19725>; else goto <D.19726>;
          <D.19725>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "major_collector.is_object_live (__target)");
          <D.19726>:
          goto <D.19727>;
          <D.19720>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 71);
          <D.19727>:
          <D.19717>:
          <D.19707>:
          <D.19690>:
        }
        _objptr = _objptr + 4;
      }
      goto <D.17939>;
      <D.17938>:
      {
        int _index;

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

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.19731>; else goto <D.19732>;
          <D.19731>:
          D.19733 = is_valid_object_pointer (__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, "is_valid_object_pointer (__target)");
          <D.19738>:
          D.19739 = sgen_ptr_in_nursery (__target);
          if (D.19739 != 0) goto <D.19740>; else goto <D.19741>;
          <D.19740>:
          D.19742 = MEM[(mword *)__target];
          D.19743 = D.19742 & 2;
          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, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.19748>:
          goto <D.19749>;
          <D.19741>:
          D.19750 = sgen_los_is_valid_object (__target);
          if (D.19750 != 0) goto <D.19751>; else goto <D.19752>;
          <D.19751>:
          D.19753 = sgen_los_object_is_pinned (__target);
          D.19754 = D.19753 == 0;
          D.19755 = (long int) D.19754;
          D.19756 = __builtin_expect (D.19755, 0);
          if (D.19756 != 0) goto <D.19757>; else goto <D.19758>;
          <D.19757>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 71, "sgen_los_object_is_pinned (__target)");
          <D.19758>:
          goto <D.19759>;
          <D.19752>:
          D.19636 = major_collector.is_valid_object;
          D.19760 = D.19636 (__target);
          if (D.19760 != 0) goto <D.19761>; else goto <D.19762>;
          <D.19761>:
          D.19592 = major_collector.is_object_live;
          D.19763 = D.19592 (__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", 71, "major_collector.is_object_live (__target)");
          <D.19768>:
          goto <D.19769>;
          <D.19762>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 71);
          <D.19769>:
          <D.19759>:
          <D.19749>:
          <D.19732>:
        }
        _objptr = _objptr + 4;
      }
      <D.17939>:
      if (_bmap != 0) goto <D.17938>; else goto <D.17940>;
      <D.17940>:
    }
    goto <D.17930>;
    <D.17941>:
    D.19770 = desc & 4294950912;
    if (D.19770 != 0) goto <D.19771>; else goto <D.19772>;
    <D.19771>:
    {
      int el_size;
      int etype;

      D.19773 = desc >> 3;
      D.19774 = (int) D.19773;
      el_size = D.19774 & 1023;
      desc.150 = (int) desc;
      etype = desc.150 & 49152;
      if (etype == 16384) goto <D.19776>; else goto <D.19777>;
      <D.19776>:
      {
        void * * p;
        void * * end_refs;

        p = start + 16;
        D.19778 = MEM[(struct MonoArray *)start].max_length;
        el_size.151 = (unsigned int) el_size;
        D.19780 = D.19778 * el_size.151;
        end_refs = p + D.19780;
        goto <D.17948>;
        <D.17947>:
        {
          char * __target;

          __target = MEM[(char * *)p];
          if (__target != 0B) goto <D.19781>; else goto <D.19782>;
          <D.19781>:
          D.19783 = is_valid_object_pointer (__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, "is_valid_object_pointer (__target)");
          <D.19788>:
          D.19789 = sgen_ptr_in_nursery (__target);
          if (D.19789 != 0) goto <D.19790>; else goto <D.19791>;
          <D.19790>:
          D.19792 = MEM[(mword *)__target];
          D.19793 = D.19792 & 2;
          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, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.19798>:
          goto <D.19799>;
          <D.19791>:
          D.19800 = sgen_los_is_valid_object (__target);
          if (D.19800 != 0) goto <D.19801>; else goto <D.19802>;
          <D.19801>:
          D.19803 = sgen_los_object_is_pinned (__target);
          D.19804 = D.19803 == 0;
          D.19805 = (long int) D.19804;
          D.19806 = __builtin_expect (D.19805, 0);
          if (D.19806 != 0) goto <D.19807>; else goto <D.19808>;
          <D.19807>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
          <D.19808>:
          goto <D.19809>;
          <D.19802>:
          D.19636 = major_collector.is_valid_object;
          D.19810 = D.19636 (__target);
          if (D.19810 != 0) goto <D.19811>; else goto <D.19812>;
          <D.19811>:
          D.19592 = major_collector.is_object_live;
          D.19813 = D.19592 (__target);
          D.19814 = D.19813 == 0;
          D.19815 = (long int) D.19814;
          D.19816 = __builtin_expect (D.19815, 0);
          if (D.19816 != 0) goto <D.19817>; else goto <D.19818>;
          <D.19817>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
          <D.19818>:
          goto <D.19819>;
          <D.19812>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
          <D.19819>:
          <D.19809>:
          <D.19799>:
          <D.19782>:
        }
        p = p + 4;
        <D.17948>:
        if (p < end_refs) goto <D.17947>; else goto <D.17949>;
        <D.17949>:
      }
      goto <D.19820>;
      <D.19777>:
      if (etype == 32768) goto <D.19821>; else goto <D.19822>;
      <D.19821>:
      {
        int offset;
        int num_refs;
        char * e_start;
        char * e_end;

        D.19602 = desc >> 16;
        D.19823 = (int) D.19602;
        offset = D.19823 & 255;
        D.19605 = desc >> 24;
        num_refs = (int) D.19605;
        e_start = start + 16;
        D.19778 = MEM[(struct MonoArray *)start].max_length;
        el_size.151 = (unsigned int) el_size;
        D.19780 = D.19778 * el_size.151;
        e_end = e_start + D.19780;
        goto <D.17961>;
        <D.17960>:
        {
          void * * p;
          int i;

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

            D.19826 = MEM[(char * *)p];
            i.153 = (sizetype) i;
            __target = D.19826 + i.153;
            if (__target != 0B) goto <D.19828>; else goto <D.19829>;
            <D.19828>:
            D.19830 = is_valid_object_pointer (__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, "is_valid_object_pointer (__target)");
            <D.19835>:
            D.19836 = sgen_ptr_in_nursery (__target);
            if (D.19836 != 0) goto <D.19837>; else goto <D.19838>;
            <D.19837>:
            D.19839 = MEM[(mword *)__target];
            D.19840 = D.19839 & 2;
            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, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.19845>:
            goto <D.19846>;
            <D.19838>:
            D.19847 = sgen_los_is_valid_object (__target);
            if (D.19847 != 0) goto <D.19848>; else goto <D.19849>;
            <D.19848>:
            D.19850 = sgen_los_object_is_pinned (__target);
            D.19851 = D.19850 == 0;
            D.19852 = (long int) D.19851;
            D.19853 = __builtin_expect (D.19852, 0);
            if (D.19853 != 0) goto <D.19854>; else goto <D.19855>;
            <D.19854>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
            <D.19855>:
            goto <D.19856>;
            <D.19849>:
            D.19636 = major_collector.is_valid_object;
            D.19857 = D.19636 (__target);
            if (D.19857 != 0) goto <D.19858>; else goto <D.19859>;
            <D.19858>:
            D.19592 = major_collector.is_object_live;
            D.19860 = D.19592 (__target);
            D.19861 = D.19860 == 0;
            D.19862 = (long int) D.19861;
            D.19863 = __builtin_expect (D.19862, 0);
            if (D.19863 != 0) goto <D.19864>; else goto <D.19865>;
            <D.19864>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
            <D.19865>:
            goto <D.19866>;
            <D.19859>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
            <D.19866>:
            <D.19856>:
            <D.19846>:
            <D.19829>:
          }
          i = i + 1;
          <D.17958>:
          if (i < num_refs) goto <D.17957>; else goto <D.17959>;
          <D.17959>:
          el_size.154 = (sizetype) el_size;
          e_start = e_start + el_size.154;
        }
        <D.17961>:
        if (e_start < e_end) goto <D.17960>; else goto <D.17962>;
        <D.17962>:
      }
      goto <D.19868>;
      <D.19822>:
      if (etype == 49152) goto <D.19869>; else goto <D.19870>;
      <D.19869>:
      {
        char * e_start;
        char * e_end;

        e_start = start + 16;
        D.19778 = MEM[(struct MonoArray *)start].max_length;
        el_size.151 = (unsigned int) el_size;
        D.19780 = D.19778 * el_size.151;
        e_end = e_start + D.19780;
        goto <D.17972>;
        <D.17971>:
        {
          void * * p;
          gsize _bmap;

          p = e_start;
          _bmap = desc >> 16;
          goto <D.17969>;
          <D.17968>:
          D.19871 = _bmap & 1;
          if (D.19871 != 0) goto <D.19872>; else goto <D.19873>;
          <D.19872>:
          {
            char * __target;

            __target = MEM[(char * *)p];
            if (__target != 0B) goto <D.19874>; else goto <D.19875>;
            <D.19874>:
            D.19876 = is_valid_object_pointer (__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, "is_valid_object_pointer (__target)");
            <D.19881>:
            D.19882 = sgen_ptr_in_nursery (__target);
            if (D.19882 != 0) goto <D.19883>; else goto <D.19884>;
            <D.19883>:
            D.19885 = MEM[(mword *)__target];
            D.19886 = D.19885 & 2;
            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, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.19891>:
            goto <D.19892>;
            <D.19884>:
            D.19893 = sgen_los_is_valid_object (__target);
            if (D.19893 != 0) goto <D.19894>; else goto <D.19895>;
            <D.19894>:
            D.19896 = sgen_los_object_is_pinned (__target);
            D.19897 = D.19896 == 0;
            D.19898 = (long int) D.19897;
            D.19899 = __builtin_expect (D.19898, 0);
            if (D.19899 != 0) goto <D.19900>; else goto <D.19901>;
            <D.19900>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "sgen_los_object_is_pinned (__target)");
            <D.19901>:
            goto <D.19902>;
            <D.19895>:
            D.19636 = major_collector.is_valid_object;
            D.19903 = D.19636 (__target);
            if (D.19903 != 0) goto <D.19904>; else goto <D.19905>;
            <D.19904>:
            D.19592 = major_collector.is_object_live;
            D.19906 = D.19592 (__target);
            D.19907 = D.19906 == 0;
            D.19908 = (long int) D.19907;
            D.19909 = __builtin_expect (D.19908, 0);
            if (D.19909 != 0) goto <D.19910>; else goto <D.19911>;
            <D.19910>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 78, "major_collector.is_object_live (__target)");
            <D.19911>:
            goto <D.19912>;
            <D.19905>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 78);
            <D.19912>:
            <D.19902>:
            <D.19892>:
            <D.19875>:
          }
          <D.19873>:
          _bmap = _bmap >> 1;
          p = p + 4;
          <D.17969>:
          if (_bmap != 0) goto <D.17968>; else goto <D.17970>;
          <D.17970>:
          el_size.154 = (sizetype) el_size;
          e_start = e_start + el_size.154;
        }
        <D.17972>:
        if (e_start < e_end) goto <D.17971>; else goto <D.17973>;
        <D.17973>:
      }
      <D.19870>:
      <D.19868>:
      <D.19820>:
    }
    <D.19772>:
    goto <D.17930>;
    <D.17974>:
    {
      void * * _objptr;
      gsize _bmap;

      _objptr = start;
      _bmap = desc >> 3;
      _objptr = _objptr + 8;
      goto <D.17979>;
      <D.17978>:
      D.19913 = _bmap & 1;
      if (D.19913 != 0) goto <D.19914>; else goto <D.19915>;
      <D.19914>:
      {
        char * __target;

        __target = MEM[(char * *)_objptr];
        if (__target != 0B) goto <D.19916>; else goto <D.19917>;
        <D.19916>:
        D.19918 = is_valid_object_pointer (__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, "is_valid_object_pointer (__target)");
        <D.19923>:
        D.19924 = sgen_ptr_in_nursery (__target);
        if (D.19924 != 0) goto <D.19925>; else goto <D.19926>;
        <D.19925>:
        D.19927 = MEM[(mword *)__target];
        D.19928 = D.19927 & 2;
        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, "SGEN_OBJECT_IS_PINNED (__target)");
        <D.19933>:
        goto <D.19934>;
        <D.19926>:
        D.19935 = sgen_los_is_valid_object (__target);
        if (D.19935 != 0) goto <D.19936>; else goto <D.19937>;
        <D.19936>:
        D.19938 = sgen_los_object_is_pinned (__target);
        D.19939 = D.19938 == 0;
        D.19940 = (long int) D.19939;
        D.19941 = __builtin_expect (D.19940, 0);
        if (D.19941 != 0) goto <D.19942>; else goto <D.19943>;
        <D.19942>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "sgen_los_object_is_pinned (__target)");
        <D.19943>:
        goto <D.19944>;
        <D.19937>:
        D.19636 = major_collector.is_valid_object;
        D.19945 = D.19636 (__target);
        if (D.19945 != 0) goto <D.19946>; else goto <D.19947>;
        <D.19946>:
        D.19592 = major_collector.is_object_live;
        D.19948 = D.19592 (__target);
        D.19949 = D.19948 == 0;
        D.19950 = (long int) D.19949;
        D.19951 = __builtin_expect (D.19950, 0);
        if (D.19951 != 0) goto <D.19952>; else goto <D.19953>;
        <D.19952>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 85, "major_collector.is_object_live (__target)");
        <D.19953>:
        goto <D.19954>;
        <D.19947>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 85);
        <D.19954>:
        <D.19944>:
        <D.19934>:
        <D.19917>:
      }
      <D.19915>:
      _bmap = _bmap >> 1;
      _objptr = _objptr + 4;
      <D.17979>:
      if (_bmap != 0) goto <D.17978>; else goto <D.17980>;
      <D.17980>:
    }
    goto <D.17930>;
    <D.17981>:
    {
      void * * _objptr;
      gsize * bitmap_data;
      int bwords;
      void * * start_run;

      _objptr = start;
      bitmap_data = sgen_get_complex_descriptor (desc);
      D.19955 = *bitmap_data;
      D.19956 = D.19955 + 4294967295;
      bwords = (int) D.19956;
      start_run = _objptr;
      bitmap_data = bitmap_data + 4;
      if (0 != 0) goto <D.19957>; else goto <D.19958>;
      <D.19957>:
      {
        struct MonoObject * myobj;

        myobj = start;
        D.19959 = myobj->vtable;
        D.19960 = D.19959->klass;
        D.19961 = D.19960->name;
        D.19959 = myobj->vtable;
        D.19960 = D.19959->klass;
        D.19962 = D.19960->name_space;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.19962, D.19961);
      }
      <D.19958>:
      goto <D.17993>;
      <D.17992>:
      {
        gsize _bmap;

        bitmap_data.155 = bitmap_data;
        bitmap_data = bitmap_data.155 + 4;
        _bmap = *bitmap_data.155;
        _objptr = start_run;
        goto <D.17990>;
        <D.17989>:
        D.19964 = _bmap & 1;
        if (D.19964 != 0) goto <D.19965>; else goto <D.19966>;
        <D.19965>:
        {
          char * __target;

          __target = MEM[(char * *)_objptr];
          if (__target != 0B) goto <D.19967>; else goto <D.19968>;
          <D.19967>:
          D.19969 = is_valid_object_pointer (__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, "is_valid_object_pointer (__target)");
          <D.19974>:
          D.19975 = sgen_ptr_in_nursery (__target);
          if (D.19975 != 0) goto <D.19976>; else goto <D.19977>;
          <D.19976>:
          D.19978 = MEM[(mword *)__target];
          D.19979 = D.19978 & 2;
          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, "SGEN_OBJECT_IS_PINNED (__target)");
          <D.19984>:
          goto <D.19985>;
          <D.19977>:
          D.19986 = sgen_los_is_valid_object (__target);
          if (D.19986 != 0) goto <D.19987>; else goto <D.19988>;
          <D.19987>:
          D.19989 = sgen_los_object_is_pinned (__target);
          D.19990 = D.19989 == 0;
          D.19991 = (long int) D.19990;
          D.19992 = __builtin_expect (D.19991, 0);
          if (D.19992 != 0) goto <D.19993>; else goto <D.19994>;
          <D.19993>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "sgen_los_object_is_pinned (__target)");
          <D.19994>:
          goto <D.19995>;
          <D.19988>:
          D.19636 = major_collector.is_valid_object;
          D.19996 = D.19636 (__target);
          if (D.19996 != 0) goto <D.19997>; else goto <D.19998>;
          <D.19997>:
          D.19592 = major_collector.is_object_live;
          D.19999 = D.19592 (__target);
          D.20000 = D.19999 == 0;
          D.20001 = (long int) D.20000;
          D.20002 = __builtin_expect (D.20001, 0);
          if (D.20002 != 0) goto <D.20003>; else goto <D.20004>;
          <D.20003>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 93, "major_collector.is_object_live (__target)");
          <D.20004>:
          goto <D.20005>;
          <D.19998>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 93);
          <D.20005>:
          <D.19995>:
          <D.19985>:
          <D.19968>:
        }
        <D.19966>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17990>:
        if (_bmap != 0) goto <D.17989>; else goto <D.17991>;
        <D.17991>:
        start_run = start_run + 128;
      }
      <D.17993>:
      bwords.156 = bwords;
      bwords = bwords.156 + -1;
      if (bwords.156 > 0) goto <D.17992>; else goto <D.17994>;
      <D.17994>:
    }
    goto <D.17930>;
    <D.17995>:
    {
      gsize * mbitmap_data;
      int mbwords;
      int el_size;
      char * e_start;
      char * e_end;

      D.20007 = vt->desc;
      mbitmap_data = sgen_get_complex_descriptor (D.20007);
      mbitmap_data.157 = mbitmap_data;
      mbitmap_data = mbitmap_data.157 + 4;
      D.20009 = *mbitmap_data.157;
      D.20010 = D.20009 + 4294967295;
      mbwords = (int) D.20010;
      D.20011 = vt->klass;
      el_size = mono_array_element_size (D.20011);
      e_start = start + 16;
      D.19778 = MEM[(struct MonoArray *)start].max_length;
      el_size.158 = (unsigned int) el_size;
      D.20013 = D.19778 * el_size.158;
      e_end = e_start + D.20013;
      if (0 != 0) goto <D.20014>; else goto <D.20015>;
      <D.20014>:
      D.20011 = vt->klass;
      D.20016 = D.20011->name;
      D.20011 = vt->klass;
      D.20017 = D.20011->name_space;
      D.20007 = vt->desc;
      monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.20007, D.20017, D.20016);
      <D.20015>:
      goto <D.18014>;
      <D.18013>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        unsigned int bwords;

        _objptr = e_start;
        bitmap_data = mbitmap_data;
        bwords = (unsigned int) mbwords;
        goto <D.18011>;
        <D.18010>:
        {
          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.18008>;
          <D.18007>:
          D.20019 = _bmap & 1;
          if (D.20019 != 0) goto <D.20020>; else goto <D.20021>;
          <D.20020>:
          {
            char * __target;

            __target = MEM[(char * *)_objptr];
            if (__target != 0B) goto <D.20022>; else goto <D.20023>;
            <D.20022>:
            D.20024 = is_valid_object_pointer (__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, "is_valid_object_pointer (__target)");
            <D.20029>:
            D.20030 = sgen_ptr_in_nursery (__target);
            if (D.20030 != 0) goto <D.20031>; else goto <D.20032>;
            <D.20031>:
            D.20033 = MEM[(mword *)__target];
            D.20034 = D.20033 & 2;
            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, "SGEN_OBJECT_IS_PINNED (__target)");
            <D.20039>:
            goto <D.20040>;
            <D.20032>:
            D.20041 = sgen_los_is_valid_object (__target);
            if (D.20041 != 0) goto <D.20042>; else goto <D.20043>;
            <D.20042>:
            D.20044 = sgen_los_object_is_pinned (__target);
            D.20045 = D.20044 == 0;
            D.20046 = (long int) D.20045;
            D.20047 = __builtin_expect (D.20046, 0);
            if (D.20047 != 0) goto <D.20048>; else goto <D.20049>;
            <D.20048>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "sgen_los_object_is_pinned (__target)");
            <D.20049>:
            goto <D.20050>;
            <D.20043>:
            D.19636 = major_collector.is_valid_object;
            D.20051 = D.19636 (__target);
            if (D.20051 != 0) goto <D.20052>; else goto <D.20053>;
            <D.20052>:
            D.19592 = major_collector.is_object_live;
            D.20054 = D.19592 (__target);
            D.20055 = D.20054 == 0;
            D.20056 = (long int) D.20055;
            D.20057 = __builtin_expect (D.20056, 0);
            if (D.20057 != 0) goto <D.20058>; else goto <D.20059>;
            <D.20058>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-scan-object.h", 102, "major_collector.is_object_live (__target)");
            <D.20059>:
            goto <D.20060>;
            <D.20053>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 102);
            <D.20060>:
            <D.20050>:
            <D.20040>:
            <D.20023>:
          }
          <D.20021>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.18008>:
          if (_bmap != 0) goto <D.18007>; else goto <D.18009>;
          <D.18009>:
          _objptr = start_run + 128;
        }
        <D.18011>:
        bwords.160 = bwords;
        bwords = bwords.160 + 4294967295;
        if (bwords.160 != 0) goto <D.18010>; else goto <D.18012>;
        <D.18012>:
        el_size.161 = (sizetype) el_size;
        e_start = e_start + el_size.161;
      }
      <D.18014>:
      if (e_start < e_end) goto <D.18013>; else goto <D.18015>;
      <D.18015>:
    }
    goto <D.17930>;
    <D.18016>:
    goto <D.17930>;
    <D.18017>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
    <D.17930>:
  }
}


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

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


check_nursery_objects_pinned_callback (char * obj, size_t size, void * data)
{
  int iftmp.164;
  unsigned int D.20072;
  unsigned int D.20073;
  unsigned int D.20075;
  _Bool D.20077;
  long int D.20078;
  long int D.20079;
  unsigned int D.20084;
  _Bool D.20085;
  long int D.20086;
  long int D.20087;
  _Bool D.20091;
  long int D.20092;
  long int D.20093;
  gboolean pinned;

  pinned = (gboolean) data;
  D.20072 = MEM[(mword *)obj];
  D.20073 = D.20072 & 1;
  if (D.20073 != 0) goto <D.20074>; else goto <D.20070>;
  <D.20074>:
  D.20072 = MEM[(mword *)obj];
  D.20075 = D.20072 & 4294967292;
  if (D.20075 != 0) goto <D.20076>; else goto <D.20070>;
  <D.20076>:
  iftmp.164 = 1;
  goto <D.20071>;
  <D.20070>:
  iftmp.164 = 0;
  <D.20071>:
  D.20077 = iftmp.164 != 0;
  D.20078 = (long int) D.20077;
  D.20079 = __builtin_expect (D.20078, 0);
  if (D.20079 != 0) goto <D.20080>; else goto <D.20081>;
  <D.20080>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 575, "!SGEN_OBJECT_IS_FORWARDED (obj)");
  <D.20081>:
  if (pinned != 0) goto <D.20082>; else goto <D.20083>;
  <D.20082>:
  D.20072 = MEM[(mword *)obj];
  D.20084 = D.20072 & 2;
  D.20085 = D.20084 == 0;
  D.20086 = (long int) D.20085;
  D.20087 = __builtin_expect (D.20086, 0);
  if (D.20087 != 0) goto <D.20088>; else goto <D.20089>;
  <D.20088>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 577, "SGEN_OBJECT_IS_PINNED (obj)");
  <D.20089>:
  goto <D.20090>;
  <D.20083>:
  D.20072 = MEM[(mword *)obj];
  D.20084 = D.20072 & 2;
  D.20091 = D.20084 != 0;
  D.20092 = (long int) D.20091;
  D.20093 = __builtin_expect (D.20092, 0);
  if (D.20093 != 0) goto <D.20094>; else goto <D.20095>;
  <D.20094>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-debug.c", 579, "!SGEN_OBJECT_IS_PINNED (obj)");
  <D.20095>:
  <D.20090>:
}