sgen_los_free_object (struct LOSObject * obj)
{
  struct FILE * gc_debug_file.0;
  char[0:] * D.20065;
  unsigned int D.20066;
  unsigned int los_memory_usage.1;
  unsigned int los_memory_usage.2;
  unsigned int los_num_objects.3;
  unsigned int los_num_objects.4;
  int pagesize.5;
  int pagesize.6;
  unsigned int pagesize.7;
  unsigned int D.20078;
  int D.20079;
  unsigned int D.20080;
  unsigned int D.20082;
  size_t size;

  size = obj->size;
  if (0 != 0) goto <D.20062>; else goto <D.20063>;
  <D.20062>:
  gc_debug_file.0 = gc_debug_file;
  D.20065 = &obj->data;
  D.20066 = obj->size;
  fprintf (gc_debug_file.0, "Freed large object %p, size %lu\n", D.20065, D.20066);
  gc_debug_file.0 = gc_debug_file;
  fflush (gc_debug_file.0);
  <D.20063>:
  los_memory_usage.1 = los_memory_usage;
  los_memory_usage.2 = los_memory_usage.1 - size;
  los_memory_usage = los_memory_usage.2;
  los_num_objects.3 = los_num_objects;
  los_num_objects.4 = los_num_objects.3 + 4294967295;
  los_num_objects = los_num_objects.4;
  if (size > 1044464) goto <D.20071>; else goto <D.20072>;
  <D.20071>:
  pagesize.5 = pagesize;
  if (pagesize.5 == 0) goto <D.20074>; else goto <D.20075>;
  <D.20074>:
  pagesize.6 = mono_pagesize ();
  pagesize = pagesize.6;
  <D.20075>:
  size = size + 16;
  pagesize.5 = pagesize;
  pagesize.7 = (unsigned int) pagesize.5;
  D.20078 = pagesize.7 + size;
  size = D.20078 + 4294967295;
  pagesize.5 = pagesize;
  D.20079 = -pagesize.5;
  D.20080 = (unsigned int) D.20079;
  size = D.20080 & size;
  sgen_free_os_memory (obj, size, 1);
  sgen_memgov_release_space (size, 2);
  goto <D.20081>;
  <D.20072>:
  D.20082 = size + 16;
  free_los_section_memory (obj, D.20082);
  <D.20081>:
}


free_los_section_memory (struct LOSObject * obj, size_t size)
{
  unsigned int obj.8;
  unsigned int D.20084;
  unsigned int D.20085;
  unsigned int D.20086;
  _Bool D.20087;
  long int D.20088;
  long int D.20089;
  _Bool D.20092;
  long int D.20093;
  long int D.20094;
  int D.20097;
  int D.20098;
  _Bool D.20099;
  long int D.20100;
  long int D.20101;
  int obj.9;
  int section.10;
  int D.20106;
  unsigned char * D.20107;
  sizetype i.11;
  unsigned char * D.20109;
  unsigned char D.20110;
  _Bool D.20111;
  long int D.20112;
  long int D.20113;
  int D.20116;
  struct LOSSection * section;
  int num_chunks;
  int i;
  int start_index;

  obj.8 = (unsigned int) obj;
  D.20084 = obj.8 & 4293918720;
  section = (struct LOSSection *) D.20084;
  size = size + 4095;
  size = size & 4294963200;
  D.20085 = size >> 12;
  num_chunks = (int) D.20085;
  D.20086 = size + 4294967280;
  D.20087 = D.20086 > 1044464;
  D.20088 = (long int) D.20087;
  D.20089 = __builtin_expect (D.20088, 0);
  if (D.20089 != 0) goto <D.20090>; else goto <D.20091>;
  <D.20090>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 267, "size > 0 && size - sizeof (LOSObject) <= LOS_SECTION_OBJECT_LIMIT");
  <D.20091>:
  D.20092 = num_chunks <= 0;
  D.20093 = (long int) D.20092;
  D.20094 = __builtin_expect (D.20093, 0);
  if (D.20094 != 0) goto <D.20095>; else goto <D.20096>;
  <D.20095>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 268, "num_chunks > 0");
  <D.20096>:
  D.20097 = section->num_free_chunks;
  D.20098 = D.20097 + num_chunks;
  section->num_free_chunks = D.20098;
  D.20097 = section->num_free_chunks;
  D.20099 = D.20097 > 255;
  D.20100 = (long int) D.20099;
  D.20101 = __builtin_expect (D.20100, 0);
  if (D.20101 != 0) goto <D.20102>; else goto <D.20103>;
  <D.20102>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 271, "section->num_free_chunks <= LOS_SECTION_NUM_CHUNKS");
  <D.20103>:
  obj.9 = (int) obj;
  section.10 = (int) section;
  D.20106 = obj.9 - section.10;
  start_index = D.20106 >> 12;
  i = start_index;
  goto <D.19946>;
  <D.19945>:
  D.20107 = section->free_chunk_map;
  i.11 = (sizetype) i;
  D.20109 = D.20107 + i.11;
  D.20110 = *D.20109;
  D.20111 = D.20110 != 0;
  D.20112 = (long int) D.20111;
  D.20113 = __builtin_expect (D.20112, 0);
  if (D.20113 != 0) goto <D.20114>; else goto <D.20115>;
  <D.20114>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 281, "!section->free_chunk_map [i]");
  <D.20115>:
  D.20107 = section->free_chunk_map;
  i.11 = (sizetype) i;
  D.20109 = D.20107 + i.11;
  *D.20109 = 1;
  i = i + 1;
  <D.19946>:
  D.20116 = start_index + num_chunks;
  if (D.20116 > i) goto <D.19945>; else goto <D.19947>;
  <D.19947>:
  add_free_chunk (obj, size);
}


add_free_chunk (struct LOSFreeChunks * free_chunks, size_t size)
{
  unsigned int D.20117;
  struct LOSFreeChunks * D.20120;
  int num_chunks;

  D.20117 = size >> 12;
  num_chunks = (int) D.20117;
  free_chunks->size = size;
  if (num_chunks > 31) goto <D.20118>; else goto <D.20119>;
  <D.20118>:
  num_chunks = 0;
  <D.20119>:
  D.20120 = los_fast_free_lists[num_chunks];
  free_chunks->next_size = D.20120;
  los_fast_free_lists[num_chunks] = free_chunks;
}


sgen_los_alloc_large_inner (struct MonoVTable * vtable, size_t size)
{
  _Bool D.20121;
  long int D.20122;
  long int D.20123;
  unsigned int D.20126;
  _Bool D.20127;
  long int D.20128;
  long int D.20129;
  int pagesize.12;
  int pagesize.13;
  unsigned int pagesize.14;
  unsigned int D.20139;
  int D.20140;
  unsigned int D.20141;
  int D.20142;
  unsigned int D.20146;
  void * D.20151;
  char[0:] * D.20152;
  unsigned int D.20153;
  unsigned int D.20154;
  _Bool D.20155;
  long int D.20156;
  long int D.20157;
  unsigned int D.20160;
  struct LOSObject * los_object_list.15;
  unsigned int los_memory_usage.16;
  unsigned int los_memory_usage.17;
  unsigned int los_num_objects.18;
  unsigned int los_num_objects.19;
  struct FILE * gc_debug_file.20;
  struct MonoClass * D.20169;
  const char * D.20170;
  struct LOSObject * obj;
  void * * vtslot;

  obj = 0B;
  D.20121 = size <= 8000;
  D.20122 = (long int) D.20121;
  D.20123 = __builtin_expect (D.20122, 0);
  if (D.20123 != 0) goto <D.20124>; else goto <D.20125>;
  <D.20124>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 334, "size > SGEN_MAX_SMALL_OBJ_SIZE");
  <D.20125>:
  D.20126 = size & 1;
  D.20127 = D.20126 != 0;
  D.20128 = (long int) D.20127;
  D.20129 = __builtin_expect (D.20128, 0);
  if (D.20129 != 0) goto <D.20130>; else goto <D.20131>;
  <D.20130>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 335, "(size & 1) == 0");
  <D.20131>:
  sgen_ensure_free_space (size);
  if (size > 1044464) goto <D.20132>; else goto <D.20133>;
  <D.20132>:
  {
    size_t alloc_size;

    alloc_size = size;
    pagesize.12 = pagesize;
    if (pagesize.12 == 0) goto <D.20135>; else goto <D.20136>;
    <D.20135>:
    pagesize.13 = mono_pagesize ();
    pagesize = pagesize.13;
    <D.20136>:
    alloc_size = alloc_size + 16;
    pagesize.12 = pagesize;
    pagesize.14 = (unsigned int) pagesize.12;
    D.20139 = pagesize.14 + alloc_size;
    alloc_size = D.20139 + 4294967295;
    pagesize.12 = pagesize;
    D.20140 = -pagesize.12;
    D.20141 = (unsigned int) D.20140;
    alloc_size = D.20141 & alloc_size;
    D.20142 = sgen_memgov_try_alloc_space (alloc_size, 2);
    if (D.20142 != 0) goto <D.20143>; else goto <D.20144>;
    <D.20143>:
    obj = sgen_alloc_os_memory (alloc_size, 3, 0B);
    <D.20144>:
  }
  goto <D.20145>;
  <D.20133>:
  D.20146 = size + 16;
  obj = get_los_section_memory (D.20146);
  if (obj != 0B) goto <D.20147>; else goto <D.20148>;
  <D.20147>:
  D.20146 = size + 16;
  memset (obj, 0, D.20146);
  <D.20148>:
  <D.20145>:
  if (obj == 0B) goto <D.20149>; else goto <D.20150>;
  <D.20149>:
  D.20151 = 0B;
  return D.20151;
  <D.20150>:
  D.20152 = &obj->data;
  D.20153 = (unsigned int) D.20152;
  D.20154 = D.20153 & 7;
  D.20155 = D.20154 != 0;
  D.20156 = (long int) D.20155;
  D.20157 = __builtin_expect (D.20156, 0);
  if (D.20157 != 0) goto <D.20158>; else goto <D.20159>;
  <D.20158>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 371, "!((mword)obj->data & (SGEN_ALLOC_ALIGN - 1))");
  <D.20159>:
  obj->size = size;
  vtslot = &obj->data;
  *vtslot = vtable;
  D.20152 = &obj->data;
  D.20153 = (unsigned int) D.20152;
  D.20152 = &obj->data;
  D.20153 = (unsigned int) D.20152;
  D.20160 = D.20153 + size;
  sgen_update_heap_boundaries (D.20153, D.20160);
  los_object_list.15 = los_object_list;
  obj->next = los_object_list.15;
  los_object_list = obj;
  los_memory_usage.16 = los_memory_usage;
  los_memory_usage.17 = los_memory_usage.16 + size;
  los_memory_usage = los_memory_usage.17;
  los_num_objects.18 = los_num_objects;
  los_num_objects.19 = los_num_objects.18 + 1;
  los_num_objects = los_num_objects.19;
  if (0 != 0) goto <D.20166>; else goto <D.20167>;
  <D.20166>:
  gc_debug_file.20 = gc_debug_file;
  D.20152 = &obj->data;
  D.20169 = vtable->klass;
  D.20170 = D.20169->name;
  fprintf (gc_debug_file.20, "Allocated large object %p, vtable: %p (%s), size: %zd\n", D.20152, vtable, D.20170, size);
  gc_debug_file.20 = gc_debug_file;
  fflush (gc_debug_file.20);
  <D.20167>:
  D.20151 = &obj->data;
  return D.20151;
}


get_los_section_memory (size_t size)
{
  unsigned int D.20172;
  unsigned int D.20173;
  _Bool D.20174;
  long int D.20175;
  long int D.20176;
  _Bool D.20179;
  long int D.20180;
  long int D.20181;
  struct LOSFreeChunks * * D.20187;
  struct LOSObject * D.20193;
  int D.20194;
  struct LOSFreeChunks * D.20199;
  unsigned char * D.20200;
  unsigned char * D.20203;
  void * D.20204;
  struct LOSSection * los_sections.21;
  int los_num_sections.22;
  int los_num_sections.23;
  struct LOSSection * section;
  struct LOSFreeChunks * free_chunks;
  int num_chunks;
  void retry = <<< error >>>;

  size = size + 4095;
  size = size & 4294963200;
  D.20172 = size >> 12;
  num_chunks = (int) D.20172;
  D.20173 = size + 4294967280;
  D.20174 = D.20173 > 1044464;
  D.20175 = (long int) D.20174;
  D.20176 = __builtin_expect (D.20175, 0);
  if (D.20176 != 0) goto <D.20177>; else goto <D.20178>;
  <D.20177>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 208, "size > 0 && size - sizeof (LOSObject) <= LOS_SECTION_OBJECT_LIMIT");
  <D.20178>:
  D.20179 = num_chunks <= 0;
  D.20180 = (long int) D.20179;
  D.20181 = __builtin_expect (D.20180, 0);
  if (D.20181 != 0) goto <D.20182>; else goto <D.20183>;
  <D.20182>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 209, "num_chunks > 0");
  <D.20183>:
  retry:
  if (num_chunks > 31) goto <D.20184>; else goto <D.20185>;
  <D.20184>:
  free_chunks = get_from_size_list (&los_fast_free_lists[0], size);
  goto <D.20186>;
  <D.20185>:
  {
    int i;

    i = num_chunks;
    goto <D.19936>;
    <D.19935>:
    D.20187 = &los_fast_free_lists[i];
    free_chunks = get_from_size_list (D.20187, size);
    if (free_chunks != 0B) goto <D.19934>; else goto <D.20188>;
    <D.20188>:
    i = i + 1;
    <D.19936>:
    if (i <= 31) goto <D.19935>; else goto <D.19934>;
    <D.19934>:
    if (free_chunks == 0B) goto <D.20189>; else goto <D.20190>;
    <D.20189>:
    free_chunks = get_from_size_list (&los_fast_free_lists[0], size);
    <D.20190>:
  }
  <D.20186>:
  if (free_chunks != 0B) goto <D.20191>; else goto <D.20192>;
  <D.20191>:
  D.20193 = free_chunks;
  return D.20193;
  <D.20192>:
  D.20194 = sgen_memgov_try_alloc_space (1048576, 2);
  if (D.20194 == 0) goto <D.20195>; else goto <D.20196>;
  <D.20195>:
  D.20193 = 0B;
  return D.20193;
  <D.20196>:
  section = sgen_alloc_os_memory_aligned (1048576, 1048576, 3, 0B);
  if (section == 0B) goto <D.20197>; else goto <D.20198>;
  <D.20197>:
  D.20193 = 0B;
  return D.20193;
  <D.20198>:
  free_chunks = section + 4096;
  free_chunks->size = 1044480;
  D.20199 = los_fast_free_lists[0];
  free_chunks->next_size = D.20199;
  los_fast_free_lists[0] = free_chunks;
  section->num_free_chunks = 255;
  D.20200 = section + 12;
  section->free_chunk_map = D.20200;
  if (0 != 0) goto <D.20201>; else goto <D.20202>;
  <D.20201>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 244, "sizeof (LOSSection) + LOS_SECTION_NUM_CHUNKS + 1 <= LOS_CHUNK_SIZE");
  <D.20202>:
  D.20203 = section->free_chunk_map;
  *D.20203 = 0;
  D.20203 = section->free_chunk_map;
  D.20204 = D.20203 + 1;
  memset (D.20204, 1, 255);
  los_sections.21 = los_sections;
  section->next = los_sections.21;
  los_sections = section;
  los_num_sections.22 = los_num_sections;
  los_num_sections.23 = los_num_sections.22 + 1;
  los_num_sections = los_num_sections.23;
  goto retry;
}


get_from_size_list (struct LOSFreeChunks * * list, size_t size)
{
  unsigned int D.20209;
  _Bool D.20210;
  long int D.20211;
  long int D.20212;
  unsigned int D.20215;
  struct LOSFreeChunks * D.20217;
  struct LOSFreeChunks * D.20220;
  struct LOSFreeChunks * D.20221;
  struct LOSFreeChunks * D.20224;
  unsigned int D.20225;
  unsigned int D.20226;
  unsigned int free_chunks.24;
  unsigned int D.20228;
  int free_chunks.25;
  int section.26;
  int D.20231;
  unsigned char * D.20232;
  sizetype i.27;
  unsigned char * D.20234;
  unsigned char D.20235;
  _Bool D.20236;
  long int D.20237;
  long int D.20238;
  int D.20241;
  int D.20242;
  unsigned int D.20243;
  unsigned int D.20244;
  int D.20245;
  _Bool D.20246;
  long int D.20247;
  long int D.20248;
  struct LOSFreeChunks * free_chunks;
  struct LOSSection * section;
  int num_chunks;
  int i;
  int start_index;

  free_chunks = 0B;
  D.20209 = size & 4095;
  D.20210 = D.20209 != 0;
  D.20211 = (long int) D.20210;
  D.20212 = __builtin_expect (D.20211, 0);
  if (D.20212 != 0) goto <D.20213>; else goto <D.20214>;
  <D.20213>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 163, "(size & (LOS_CHUNK_SIZE - 1)) == 0");
  <D.20214>:
  goto <D.19922>;
  <D.19921>:
  free_chunks = *list;
  D.20215 = free_chunks->size;
  if (D.20215 >= size) goto <D.19920>; else goto <D.20216>;
  <D.20216>:
  D.20217 = *list;
  list = &D.20217->next_size;
  <D.19922>:
  D.20217 = *list;
  if (D.20217 != 0B) goto <D.19921>; else goto <D.19920>;
  <D.19920>:
  D.20217 = *list;
  if (D.20217 == 0B) goto <D.20218>; else goto <D.20219>;
  <D.20218>:
  D.20220 = 0B;
  return D.20220;
  <D.20219>:
  D.20221 = free_chunks->next_size;
  *list = D.20221;
  D.20215 = free_chunks->size;
  if (D.20215 > size) goto <D.20222>; else goto <D.20223>;
  <D.20222>:
  D.20224 = free_chunks + size;
  D.20215 = free_chunks->size;
  D.20225 = D.20215 - size;
  add_free_chunk (D.20224, D.20225);
  <D.20223>:
  D.20226 = size >> 12;
  num_chunks = (int) D.20226;
  free_chunks.24 = (unsigned int) free_chunks;
  D.20228 = free_chunks.24 & 4293918720;
  section = (struct LOSSection *) D.20228;
  free_chunks.25 = (int) free_chunks;
  section.26 = (int) section;
  D.20231 = free_chunks.25 - section.26;
  start_index = D.20231 >> 12;
  i = start_index;
  goto <D.19924>;
  <D.19923>:
  D.20232 = section->free_chunk_map;
  i.27 = (sizetype) i;
  D.20234 = D.20232 + i.27;
  D.20235 = *D.20234;
  D.20236 = D.20235 == 0;
  D.20237 = (long int) D.20236;
  D.20238 = __builtin_expect (D.20237, 0);
  if (D.20238 != 0) goto <D.20239>; else goto <D.20240>;
  <D.20239>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 186, "section->free_chunk_map [i]");
  <D.20240>:
  D.20232 = section->free_chunk_map;
  i.27 = (sizetype) i;
  D.20234 = D.20232 + i.27;
  *D.20234 = 0;
  i = i + 1;
  <D.19924>:
  D.20241 = start_index + num_chunks;
  if (D.20241 > i) goto <D.19923>; else goto <D.19925>;
  <D.19925>:
  D.20242 = section->num_free_chunks;
  D.20243 = (unsigned int) D.20242;
  D.20226 = size >> 12;
  D.20244 = D.20243 - D.20226;
  D.20245 = (int) D.20244;
  section->num_free_chunks = D.20245;
  D.20242 = section->num_free_chunks;
  D.20246 = D.20242 < 0;
  D.20247 = (long int) D.20246;
  D.20248 = __builtin_expect (D.20247, 0);
  if (D.20248 != 0) goto <D.20249>; else goto <D.20250>;
  <D.20249>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 191, "section->num_free_chunks >= 0");
  <D.20250>:
  D.20220 = free_chunks;
  return D.20220;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.20254;
  int D.20259;
  void * D.20261;
  unsigned int D.20262;

  D.20254 = __builtin_constant_p (__len);
  if (D.20254 != 0) goto <D.20255>; else goto <D.20256>;
  <D.20255>:
  if (__len == 0) goto <D.20257>; else goto <D.20258>;
  <D.20257>:
  D.20259 = __builtin_constant_p (__ch);
  if (D.20259 == 0) goto <D.20252>; else goto <D.20260>;
  <D.20260>:
  if (__ch != 0) goto <D.20252>; else goto <D.20253>;
  <D.20252>:
  __warn_memset_zero_len ();
  D.20261 = __dest;
  return D.20261;
  <D.20253>:
  <D.20258>:
  <D.20256>:
  D.20262 = __builtin_object_size (__dest, 0);
  D.20261 = __builtin___memset_chk (__dest, __ch, __len, D.20262);
  return D.20261;
}


sgen_los_sweep ()
{
  int D.20264;
  int los_num_sections.28;
  int los_num_sections.29;
  unsigned char * D.20272;
  sizetype i.30;
  unsigned char * D.20274;
  unsigned char D.20275;
  sizetype j.31;
  unsigned char * D.20280;
  unsigned char D.20281;
  int D.20282;
  sizetype D.20283;
  struct LOSFreeChunks * D.20284;
  int D.20285;
  int D.20286;
  unsigned int D.20287;
  _Bool D.20288;
  long int D.20289;
  long int D.20290;
  struct LOSSection * section;
  struct LOSSection * prev;
  int i;
  int num_sections;

  num_sections = 0;
  i = 0;
  goto <D.19968>;
  <D.19967>:
  los_fast_free_lists[i] = 0B;
  i = i + 1;
  <D.19968>:
  if (i <= 31) goto <D.19967>; else goto <D.19969>;
  <D.19969>:
  prev = 0B;
  section = los_sections;
  goto <D.19971>;
  <D.19979>:
  D.20264 = section->num_free_chunks;
  if (D.20264 == 255) goto <D.20265>; else goto <D.20266>;
  <D.20265>:
  {
    struct LOSSection * next;

    next = section->next;
    if (prev != 0B) goto <D.20267>; else goto <D.20268>;
    <D.20267>:
    prev->next = next;
    goto <D.20269>;
    <D.20268>:
    los_sections = next;
    <D.20269>:
    sgen_free_os_memory (section, 1048576, 1);
    sgen_memgov_release_space (1048576, 2);
    section = next;
    los_num_sections.28 = los_num_sections;
    los_num_sections.29 = los_num_sections.28 + -1;
    los_num_sections = los_num_sections.29;
    // predicted unlikely by continue predictor.
    goto <D.19971>;
  }
  <D.20266>:
  i = 0;
  goto <D.19977>;
  <D.19976>:
  D.20272 = section->free_chunk_map;
  i.30 = (sizetype) i;
  D.20274 = D.20272 + i.30;
  D.20275 = *D.20274;
  if (D.20275 != 0) goto <D.20276>; else goto <D.20277>;
  <D.20276>:
  {
    int j;

    j = i + 1;
    goto <D.19974>;
    <D.19973>:
    j = j + 1;
    <D.19974>:
    if (j <= 255) goto <D.20278>; else goto <D.19975>;
    <D.20278>:
    D.20272 = section->free_chunk_map;
    j.31 = (sizetype) j;
    D.20280 = D.20272 + j.31;
    D.20281 = *D.20280;
    if (D.20281 != 0) goto <D.19973>; else goto <D.19975>;
    <D.19975>:
    D.20282 = i << 12;
    D.20283 = (sizetype) D.20282;
    D.20284 = section + D.20283;
    D.20285 = j - i;
    D.20286 = D.20285 << 12;
    D.20287 = (unsigned int) D.20286;
    add_free_chunk (D.20284, D.20287);
    i = j + -1;
  }
  <D.20277>:
  i = i + 1;
  <D.19977>:
  if (i <= 255) goto <D.19976>; else goto <D.19978>;
  <D.19978>:
  prev = section;
  section = section->next;
  num_sections = num_sections + 1;
  <D.19971>:
  if (section != 0B) goto <D.19979>; else goto <D.19980>;
  <D.19980>:
  los_num_sections.28 = los_num_sections;
  D.20288 = los_num_sections.28 != num_sections;
  D.20289 = (long int) D.20288;
  D.20290 = __builtin_expect (D.20289, 0);
  if (D.20290 != 0) goto <D.20291>; else goto <D.20292>;
  <D.20291>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 447, "los_num_sections == num_sections");
  <D.20292>:
}


sgen_ptr_is_in_los (char * ptr, char * * start)
{
  unsigned int D.20293;
  char[0:] * D.20294;
  gboolean D.20299;
  struct LOSObject * obj;

  *start = 0B;
  obj = los_object_list;
  goto <D.19988>;
  <D.19987>:
  {
    char * end;

    D.20293 = obj->size;
    end = &obj->data[D.20293];
    D.20294 = &obj->data;
    if (D.20294 <= ptr) goto <D.20295>; else goto <D.20296>;
    <D.20295>:
    if (ptr < end) goto <D.20297>; else goto <D.20298>;
    <D.20297>:
    D.20294 = &obj->data;
    *start = D.20294;
    D.20299 = 1;
    return D.20299;
    <D.20298>:
    <D.20296>:
  }
  obj = obj->next;
  <D.19988>:
  if (obj != 0B) goto <D.19987>; else goto <D.19989>;
  <D.19989>:
  D.20299 = 0;
  return D.20299;
}


sgen_los_iterate_objects (void (*IterateObjectCallbackFunc) (char *, size_t, void *) cb, void * user_data)
{
  char[0:] * D.20301;
  unsigned int D.20302;
  struct LOSObject * obj;

  obj = los_object_list;
  goto <D.19996>;
  <D.19995>:
  D.20301 = &obj->data;
  D.20302 = obj->size;
  cb (D.20301, D.20302, user_data);
  obj = obj->next;
  <D.19996>:
  if (obj != 0B) goto <D.19995>; else goto <D.19997>;
  <D.19997>:
}


sgen_los_is_valid_object (char * object)
{
  char[0:] * D.20303;
  gboolean D.20306;
  struct LOSObject * obj;

  obj = los_object_list;
  goto <D.20003>;
  <D.20002>:
  D.20303 = &obj->data;
  if (D.20303 == object) goto <D.20304>; else goto <D.20305>;
  <D.20304>:
  D.20306 = 1;
  return D.20306;
  <D.20305>:
  obj = obj->next;
  <D.20003>:
  if (obj != 0B) goto <D.20002>; else goto <D.20004>;
  <D.20004>:
  D.20306 = 0;
  return D.20306;
}


mono_sgen_los_describe_pointer (char * ptr)
{
  char[0:] * D.20310;
  unsigned int D.20312;
  char * D.20313;
  unsigned int D.20317;
  unsigned int D.20318;
  int gc_debug_level.32;
  _Bool D.20322;
  long int D.20323;
  long int D.20324;
  struct FILE * gc_debug_file.33;
  int size.34;
  _Bool D.20329;
  int D.20330;
  int ptr.35;
  int D.20335;
  int D.20336;
  gboolean D.20337;
  struct LOSObject * obj;

  obj = los_object_list;
  goto <D.20015>;
  <D.20014>:
  {
    struct MonoVTable * vtable;
    const char * los_kind;
    mword size;
    gboolean pinned;

    D.20310 = &obj->data;
    if (D.20310 > ptr) goto <D.20308>; else goto <D.20311>;
    <D.20311>:
    D.20312 = obj->size;
    D.20313 = &obj->data[D.20312];
    if (D.20313 <= ptr) goto <D.20308>; else goto <D.20309>;
    <D.20308>:
    // predicted unlikely by continue predictor.
    goto <D.20013>;
    <D.20309>:
    size = sgen_los_object_size (obj);
    D.20310 = &obj->data;
    pinned = sgen_los_object_is_pinned (D.20310);
    if (size > 1044464) goto <D.20314>; else goto <D.20315>;
    <D.20314>:
    los_kind = "huge-los-ptr";
    goto <D.20316>;
    <D.20315>:
    los_kind = "los-ptr";
    <D.20316>:
    D.20310 = &obj->data;
    D.20317 = MEM[(mword *)D.20310];
    D.20318 = D.20317 & 4294967292;
    vtable = (struct MonoVTable *) D.20318;
    D.20310 = &obj->data;
    if (D.20310 == ptr) goto <D.20319>; else goto <D.20320>;
    <D.20319>:
    gc_debug_level.32 = gc_debug_level;
    D.20322 = gc_debug_level.32 >= 0;
    D.20323 = (long int) D.20322;
    D.20324 = __builtin_expect (D.20323, 0);
    if (D.20324 != 0) goto <D.20325>; else goto <D.20326>;
    <D.20325>:
    gc_debug_file.33 = gc_debug_file;
    size.34 = (int) size;
    D.20329 = pinned != 0;
    D.20330 = (int) D.20329;
    fprintf (gc_debug_file.33, "%s (size %d pin %d)\n\n", los_kind, size.34, D.20330);
    gc_debug_file.33 = gc_debug_file;
    fflush (gc_debug_file.33);
    <D.20326>:
    goto <D.20331>;
    <D.20320>:
    gc_debug_level.32 = gc_debug_level;
    D.20322 = gc_debug_level.32 >= 0;
    D.20323 = (long int) D.20322;
    D.20324 = __builtin_expect (D.20323, 0);
    if (D.20324 != 0) goto <D.20332>; else goto <D.20333>;
    <D.20332>:
    gc_debug_file.33 = gc_debug_file;
    ptr.35 = (int) ptr;
    D.20310 = &obj->data;
    D.20335 = (int) D.20310;
    D.20336 = ptr.35 - D.20335;
    size.34 = (int) size;
    D.20329 = pinned != 0;
    D.20330 = (int) D.20329;
    fprintf (gc_debug_file.33, "%s (interior-ptr offset %td size %d pin %d)\n", los_kind, D.20336, size.34, D.20330);
    gc_debug_file.33 = gc_debug_file;
    fflush (gc_debug_file.33);
    <D.20333>:
    <D.20331>:
    D.20337 = 1;
    return D.20337;
  }
  <D.20013>:
  obj = obj->next;
  <D.20015>:
  if (obj != 0B) goto <D.20014>; else goto <D.20016>;
  <D.20016>:
  D.20337 = 0;
  return D.20337;
}


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

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


sgen_los_iterate_live_block_ranges (void (*sgen_cardtable_block_callback) (mword, mword) callback)
{
  char[0:] * D.20341;
  unsigned int D.20342;
  unsigned int D.20343;
  void * D.20344;
  unsigned int D.20345;
  int D.20346;
  unsigned int D.20349;
  unsigned int D.20350;
  struct LOSObject * obj;

  obj = los_object_list;
  goto <D.20023>;
  <D.20022>:
  {
    struct MonoVTable * vt;

    D.20341 = &obj->data;
    D.20342 = MEM[(mword *)D.20341];
    D.20343 = D.20342 & 4294967292;
    vt = (struct MonoVTable *) D.20343;
    D.20344 = vt->gc_descr;
    D.20345 = (unsigned int) D.20344;
    D.20346 = sgen_gc_descr_has_references (D.20345);
    if (D.20346 != 0) goto <D.20347>; else goto <D.20348>;
    <D.20347>:
    D.20341 = &obj->data;
    D.20349 = (unsigned int) D.20341;
    D.20350 = obj->size;
    callback (D.20349, D.20350);
    <D.20348>:
  }
  obj = obj->next;
  <D.20023>:
  if (obj != 0B) goto <D.20022>; else goto <D.20024>;
  <D.20024>:
}


sgen_gc_descr_has_references (mword desc)
{
  unsigned int D.20351;
  gboolean D.20354;
  unsigned int D.20355;
  unsigned int D.20358;

  D.20351 = desc & 4294901767;
  if (D.20351 == 1) goto <D.20352>; else goto <D.20353>;
  <D.20352>:
  D.20354 = 0;
  return D.20354;
  <D.20353>:
  D.20355 = desc & 49159;
  if (D.20355 == 4) goto <D.20356>; else goto <D.20357>;
  <D.20356>:
  D.20354 = 0;
  return D.20354;
  <D.20357>:
  D.20358 = desc & 7;
  if (D.20358 == 7) goto <D.20359>; else goto <D.20360>;
  <D.20359>:
  D.20354 = 0;
  return D.20354;
  <D.20360>:
  D.20354 = 1;
  return D.20354;
}


sgen_los_scan_card_table (gboolean mod_union, struct SgenGrayQueue * queue)
{
  _Bool D.20364;
  long int D.20365;
  long int D.20366;
  char[0:] * D.20369;
  unsigned int D.20370;
  struct LOSObject * obj;

  obj = los_object_list;
  goto <D.20032>;
  <D.20031>:
  {
    guint8 * cards;

    cards = 0B;
    if (mod_union != 0) goto <D.20362>; else goto <D.20363>;
    <D.20362>:
    cards = obj->cardtable_mod_union;
    D.20364 = cards == 0B;
    D.20365 = (long int) D.20364;
    D.20366 = __builtin_expect (D.20365, 0);
    if (D.20366 != 0) goto <D.20367>; else goto <D.20368>;
    <D.20367>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-los.c", 544, "cards");
    <D.20368>:
    <D.20363>:
    D.20369 = &obj->data;
    D.20370 = obj->size;
    sgen_cardtable_scan_object (D.20369, D.20370, cards, mod_union, queue);
  }
  obj = obj->next;
  <D.20032>:
  if (obj != 0B) goto <D.20031>; else goto <D.20033>;
  <D.20033>:
}


sgen_los_update_cardtable_mod_union ()
{
  guint8 * D.20371;
  char[0:] * D.20372;
  unsigned int D.20373;
  guint8 * D.20374;
  struct LOSObject * obj;

  obj = los_object_list;
  goto <D.20039>;
  <D.20038>:
  D.20371 = obj->cardtable_mod_union;
  D.20372 = &obj->data;
  D.20373 = obj->size;
  D.20374 = sgen_card_table_update_mod_union (D.20371, D.20372, D.20373, 0B);
  obj->cardtable_mod_union = D.20374;
  obj = obj->next;
  <D.20039>:
  if (obj != 0B) goto <D.20038>; else goto <D.20040>;
  <D.20040>:
}


sgen_los_object_size (struct LOSObject * obj)
{
  mword D.20375;
  unsigned int D.20376;

  D.20376 = obj->size;
  D.20375 = D.20376 & 4294967294;
  return D.20375;
}


sgen_los_header_for_object (char * data)
{
  struct LOSObject * D.20378;

  D.20378 = data + 4294967280;
  return D.20378;
}


sgen_los_pin_object (char * data)
{
  unsigned int D.20380;
  unsigned int D.20381;
  struct LOSObject * obj;

  obj = sgen_los_header_for_object (data);
  D.20380 = obj->size;
  D.20381 = D.20380 | 1;
  obj->size = D.20381;
}


sgen_los_unpin_object (char * data)
{
  unsigned int D.20382;
  struct LOSObject * obj;

  obj = sgen_los_header_for_object (data);
  D.20382 = sgen_los_object_size (obj);
  obj->size = D.20382;
}


sgen_los_object_is_pinned (char * data)
{
  gboolean D.20383;
  unsigned int D.20384;
  int D.20385;
  struct LOSObject * obj;

  obj = sgen_los_header_for_object (data);
  D.20384 = obj->size;
  D.20385 = (int) D.20384;
  D.20383 = D.20385 & 1;
  return D.20383;
}