GC_alloc_reclaim_list (struct obj_kind * kind)
{
  GC_bool D.6111;
  struct hblk * * result;

  result = GC_scratch_alloc (2056);
  if (result == 0B) goto <D.6109>; else goto <D.6110>;
  <D.6109>:
  D.6111 = 0;
  return D.6111;
  <D.6110>:
  memset (result, 0, 2056);
  kind->ok_reclaim_list = result;
  D.6111 = 1;
  return D.6111;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.6115;
  int D.6120;
  void * D.6122;
  long unsigned int D.6123;

  D.6115 = __builtin_constant_p (__len);
  if (D.6115 != 0) goto <D.6116>; else goto <D.6117>;
  <D.6116>:
  if (__len == 0) goto <D.6118>; else goto <D.6119>;
  <D.6118>:
  D.6120 = __builtin_constant_p (__ch);
  if (D.6120 == 0) goto <D.6113>; else goto <D.6121>;
  <D.6121>:
  if (__ch != 0) goto <D.6113>; else goto <D.6114>;
  <D.6113>:
  __warn_memset_zero_len ();
  D.6122 = __dest;
  return D.6122;
  <D.6114>:
  <D.6119>:
  <D.6117>:
  D.6123 = __builtin_object_size (__dest, 0);
  D.6122 = __builtin___memset_chk (__dest, __ch, __len, D.6123);
  return D.6122;
}


GC_alloc_large (word lw, int k, unsigned int flags)
{
  long unsigned int D.6125;
  long unsigned int D.6126;
  int GC_is_initialized.0;
  int GC_incremental.1;
  int GC_dont_gc.2;
  int D.6136;
  _Bool D.6138;
  int D.6139;
  int D.6140;
  unsigned int D.6144;
  unsigned int D.6145;
  long unsigned int D.6148;
  long unsigned int D.6149;
  long unsigned int D.6150;
  long unsigned int D.6151;
  long unsigned int D.6154;
  int D.6155;
  long unsigned int D.6156;
  long unsigned int D.6157;
  long unsigned int D.6158;
  char * D.6159;
  struct hblk * h;
  word n_blocks;
  char * result;

  D.6125 = lw << 3;
  D.6126 = D.6125 + 4095;
  n_blocks = D.6126 >> 12;
  GC_is_initialized.0 = GC_is_initialized;
  if (GC_is_initialized.0 == 0) goto <D.6128>; else goto <D.6129>;
  <D.6128>:
  GC_init_inner ();
  <D.6129>:
  GC_incremental.1 = GC_incremental;
  if (GC_incremental.1 != 0) goto <D.6131>; else goto <D.6132>;
  <D.6131>:
  GC_dont_gc.2 = GC_dont_gc;
  if (GC_dont_gc.2 == 0) goto <D.6134>; else goto <D.6135>;
  <D.6134>:
  D.6136 = (int) n_blocks;
  GC_collect_a_little_inner (D.6136);
  <D.6135>:
  <D.6132>:
  h = GC_allochblk (lw, k, flags);
  goto <D.6045>;
  <D.6044>:
  h = GC_allochblk (lw, k, flags);
  <D.6045>:
  if (h == 0B) goto <D.6137>; else goto <D.6046>;
  <D.6137>:
  D.6138 = flags != 0;
  D.6139 = (int) D.6138;
  D.6140 = GC_collect_or_expand (n_blocks, D.6139);
  if (D.6140 != 0) goto <D.6044>; else goto <D.6046>;
  <D.6046>:
  if (h == 0B) goto <D.6141>; else goto <D.6142>;
  <D.6141>:
  result = 0B;
  goto <D.6143>;
  <D.6142>:
  {
    int total_bytes;

    D.6144 = (unsigned int) n_blocks;
    D.6145 = D.6144 * 4096;
    total_bytes = (int) D.6145;
    if (n_blocks > 1) goto <D.6146>; else goto <D.6147>;
    <D.6146>:
    D.6148 = GC_arrays._large_allocd_bytes;
    D.6149 = (long unsigned int) total_bytes;
    D.6150 = D.6148 + D.6149;
    GC_arrays._large_allocd_bytes = D.6150;
    D.6148 = GC_arrays._large_allocd_bytes;
    D.6151 = GC_arrays._max_large_allocd_bytes;
    if (D.6148 > D.6151) goto <D.6152>; else goto <D.6153>;
    <D.6152>:
    D.6148 = GC_arrays._large_allocd_bytes;
    GC_arrays._max_large_allocd_bytes = D.6148;
    <D.6153>:
    <D.6147>:
    result = &h->hb_body;
    D.6154 = GC_arrays._words_wasted;
    D.6155 = total_bytes >> 3;
    D.6156 = (long unsigned int) D.6155;
    D.6157 = D.6156 - lw;
    D.6158 = D.6154 + D.6157;
    GC_arrays._words_wasted = D.6158;
  }
  <D.6143>:
  D.6159 = result;
  return D.6159;
}


GC_alloc_large_and_clear (word lw, int k, unsigned int flags)
{
  long unsigned int D.6161;
  long unsigned int D.6162;
  char * D.6165;
  int GC_debugging_started.3;
  int D.6170;
  long unsigned int D.6171;
  char * result;
  word n_blocks;

  result = GC_alloc_large (lw, k, flags);
  D.6161 = lw << 3;
  D.6162 = D.6161 + 4095;
  n_blocks = D.6162 >> 12;
  if (result == 0B) goto <D.6163>; else goto <D.6164>;
  <D.6163>:
  D.6165 = 0B;
  return D.6165;
  <D.6164>:
  GC_debugging_started.3 = GC_debugging_started;
  if (GC_debugging_started.3 != 0) goto <D.6166>; else goto <D.6169>;
  <D.6169>:
  D.6170 = GC_obj_kinds[k].ok_init;
  if (D.6170 != 0) goto <D.6166>; else goto <D.6167>;
  <D.6166>:
  D.6171 = n_blocks * 4096;
  memset (result, 0, D.6171);
  <D.6167>:
  D.6165 = result;
  return D.6165;
}


GC_generic_malloc_inner (word lb, int k)
{
  int GC_all_interior_pointers.4;
  long unsigned int D.6174;
  long unsigned int D.6175;
  long unsigned int D.6178;
  long unsigned int D.6179;
  unsigned int D.6180;
  char * * D.6181;
  long unsigned int D.6182;
  int GC_is_initialized.5;
  char * D.6192;
  struct hblk * * D.6193;
  int D.6196;
  char * D.6199;
  int D.6201;
  long unsigned int D.6202;
  long unsigned int D.6203;
  long unsigned int D.6204;
  long unsigned int D.6205;
  register word lw;
  register char * op;
  register char * * opp;
  void out = <<< error >>>;

  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  D.6174 = (long unsigned int) GC_all_interior_pointers.4;
  D.6175 = 2048 - D.6174;
  if (D.6175 >= lb) goto <D.6176>; else goto <D.6177>;
  <D.6176>:
  {
    register struct obj_kind * kind;

    D.6178 = (long unsigned int) k;
    D.6179 = D.6178 * 32;
    kind = &GC_obj_kinds + D.6179;
    D.6180 = GC_arrays._size_map[lb];
    lw = (word) D.6180;
    D.6181 = kind->ok_freelist;
    D.6182 = lw * 8;
    opp = D.6181 + D.6182;
    op = *opp;
    if (op == 0B) goto <D.6183>; else goto <D.6184>;
    <D.6183>:
    D.6180 = GC_arrays._size_map[lb];
    if (D.6180 == 0) goto <D.6185>; else goto <D.6186>;
    <D.6185>:
    GC_is_initialized.5 = GC_is_initialized;
    if (GC_is_initialized.5 == 0) goto <D.6188>; else goto <D.6189>;
    <D.6188>:
    GC_init_inner ();
    <D.6189>:
    D.6180 = GC_arrays._size_map[lb];
    if (D.6180 == 0) goto <D.6190>; else goto <D.6191>;
    <D.6190>:
    GC_extend_size_map (lb);
    <D.6191>:
    D.6192 = GC_generic_malloc_inner (lb, k);
    return D.6192;
    <D.6186>:
    D.6193 = kind->ok_reclaim_list;
    if (D.6193 == 0B) goto <D.6194>; else goto <D.6195>;
    <D.6194>:
    D.6196 = GC_alloc_reclaim_list (kind);
    if (D.6196 == 0) goto out; else goto <D.6197>;
    <D.6197>:
    <D.6195>:
    op = GC_allocobj (lw, k);
    if (op == 0B) goto out; else goto <D.6198>;
    <D.6198>:
    <D.6184>:
    D.6199 = MEM[(char * *)op];
    *opp = D.6199;
    MEM[(char * *)op] = 0B;
  }
  goto <D.6200>;
  <D.6177>:
  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  D.6201 = GC_all_interior_pointers.4 + 7;
  D.6202 = (long unsigned int) D.6201;
  D.6203 = D.6202 + lb;
  lw = D.6203 >> 3;
  op = GC_alloc_large_and_clear (lw, k, 0);
  <D.6200>:
  D.6204 = GC_arrays._words_allocd;
  D.6205 = D.6204 + lw;
  GC_arrays._words_allocd = D.6205;
  out:
  D.6192 = op;
  return D.6192;
}


GC_generic_malloc_inner_ignore_off_page (size_t lb, int k)
{
  char * D.6209;
  int GC_all_interior_pointers.6;
  int D.6211;
  long unsigned int D.6212;
  long unsigned int D.6213;
  long unsigned int D.6214;
  long unsigned int D.6215;
  register word lw;
  char * op;

  if (lb <= 4096) goto <D.6207>; else goto <D.6208>;
  <D.6207>:
  D.6209 = GC_generic_malloc_inner (lb, k);
  return D.6209;
  <D.6208>:
  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  D.6211 = GC_all_interior_pointers.6 + 7;
  D.6212 = (long unsigned int) D.6211;
  D.6213 = D.6212 + lb;
  lw = D.6213 >> 3;
  op = GC_alloc_large_and_clear (lw, k, 1);
  D.6214 = GC_arrays._words_allocd;
  D.6215 = D.6214 + lw;
  GC_arrays._words_allocd = D.6215;
  D.6209 = op;
  return D.6209;
}


GC_generic_malloc (word lb, int k)
{
  int GC_have_errors.7;
  int GC_all_interior_pointers.8;
  long unsigned int D.6221;
  long unsigned int D.6222;
  int D.6225;
  int D.6229;
  long unsigned int D.6230;
  long unsigned int D.6231;
  long unsigned int D.6232;
  long unsigned int D.6233;
  int D.6234;
  int GC_debugging_started.9;
  long unsigned int D.6242;
  word * D.6244;
  long unsigned int D.6245;
  sizetype D.6246;
  word * D.6247;
  sizetype D.6248;
  word * D.6249;
  long unsigned int D.6250;
  long unsigned int D.6251;
  char * D.6260;
  void * (*<T707>) (size_t) GC_oom_fn.10;
  char * result;

  GC_have_errors.7 = GC_have_errors;
  if (GC_have_errors.7 != 0) goto <D.6218>; else goto <D.6219>;
  <D.6218>:
  GC_print_all_errors ();
  <D.6219>:
  GC_notify_or_invoke_finalizers ();
  GC_all_interior_pointers.8 = GC_all_interior_pointers;
  D.6221 = (long unsigned int) GC_all_interior_pointers.8;
  D.6222 = 2048 - D.6221;
  if (D.6222 >= lb) goto <D.6223>; else goto <D.6224>;
  <D.6223>:
  D.6225 = GC_test_and_set (&GC_allocate_lock);
  if (D.6225 != 0) goto <D.6226>; else goto <D.6227>;
  <D.6226>:
  GC_lock ();
  <D.6227>:
  result = GC_generic_malloc_inner (lb, k);
  GC_clear (&GC_allocate_lock);
  goto <D.6228>;
  <D.6224>:
  {
    word lw;
    word n_blocks;
    GC_bool init;

    GC_all_interior_pointers.8 = GC_all_interior_pointers;
    D.6229 = GC_all_interior_pointers.8 + 7;
    D.6230 = (long unsigned int) D.6229;
    D.6231 = D.6230 + lb;
    lw = D.6231 >> 3;
    D.6232 = lw << 3;
    D.6233 = D.6232 + 4095;
    n_blocks = D.6233 >> 12;
    init = GC_obj_kinds[k].ok_init;
    D.6234 = GC_test_and_set (&GC_allocate_lock);
    if (D.6234 != 0) goto <D.6235>; else goto <D.6236>;
    <D.6235>:
    GC_lock ();
    <D.6236>:
    result = GC_alloc_large (lw, k, 0);
    if (result != 0B) goto <D.6237>; else goto <D.6238>;
    <D.6237>:
    GC_debugging_started.9 = GC_debugging_started;
    if (GC_debugging_started.9 != 0) goto <D.6240>; else goto <D.6241>;
    <D.6240>:
    D.6242 = n_blocks * 4096;
    memset (result, 0, D.6242);
    goto <D.6243>;
    <D.6241>:
    MEM[(word *)result] = 0;
    D.6244 = result + 8;
    *D.6244 = 0;
    D.6245 = lw * 8;
    D.6246 = D.6245 + 18446744073709551608;
    D.6247 = result + D.6246;
    *D.6247 = 0;
    D.6245 = lw * 8;
    D.6248 = D.6245 + 18446744073709551600;
    D.6249 = result + D.6248;
    *D.6249 = 0;
    <D.6243>:
    <D.6238>:
    D.6250 = GC_arrays._words_allocd;
    D.6251 = D.6250 + lw;
    GC_arrays._words_allocd = D.6251;
    GC_clear (&GC_allocate_lock);
    if (init != 0) goto <D.6252>; else goto <D.6253>;
    <D.6252>:
    GC_debugging_started.9 = GC_debugging_started;
    if (GC_debugging_started.9 == 0) goto <D.6254>; else goto <D.6255>;
    <D.6254>:
    if (result != 0B) goto <D.6256>; else goto <D.6257>;
    <D.6256>:
    D.6242 = n_blocks * 4096;
    memset (result, 0, D.6242);
    <D.6257>:
    <D.6255>:
    <D.6253>:
  }
  <D.6228>:
  if (result == 0B) goto <D.6258>; else goto <D.6259>;
  <D.6258>:
  GC_oom_fn.10 = GC_oom_fn;
  D.6260 = GC_oom_fn.10 (lb);
  return D.6260;
  <D.6259>:
  D.6260 = result;
  return D.6260;
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.6263;
  int oldval;
  int temp;

  temp = 1;
  __asm__ __volatile__("1:	lwarx %0,0,%1
	cmpwi %0, 0
	bne 2f
	stwcx. %2,0,%1
	bne- 1b
	sync
2:	
" : "=&r" oldval : "r" addr, "r" temp : "memory", "cr0");
  D.6263 = oldval;
  return D.6263;
}


GC_clear (volatile unsigned int * addr)
{
  __asm__ __volatile__("lwsync" :  :  : "memory");
  *addr = 0;
}


GC_malloc_atomic (size_t lb)
{
  int GC_all_interior_pointers.11;
  long unsigned int D.6266;
  long unsigned int D.6267;
  _Bool D.6268;
  long int D.6269;
  long int D.6270;
  unsigned int D.6273;
  int D.6274;
  _Bool D.6277;
  long int D.6278;
  long int D.6279;
  void * D.6282;
  char * D.6283;
  char * D.6284;
  long unsigned int D.6285;
  long unsigned int D.6286;
  char * D.6287;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.11 = GC_all_interior_pointers;
  D.6266 = (long unsigned int) GC_all_interior_pointers.11;
  D.6267 = 2048 - D.6266;
  D.6268 = D.6267 >= lb;
  D.6269 = (long int) D.6268;
  D.6270 = __builtin_expect (D.6269, 1);
  if (D.6270 != 0) goto <D.6271>; else goto <D.6272>;
  <D.6271>:
  D.6273 = GC_arrays._size_map[lb];
  lw = (word) D.6273;
  opp = &GC_arrays._aobjfreelist[lw];
  D.6274 = GC_test_and_set (&GC_allocate_lock);
  if (D.6274 != 0) goto <D.6275>; else goto <D.6276>;
  <D.6275>:
  GC_lock ();
  <D.6276>:
  op = *opp;
  D.6277 = op == 0B;
  D.6278 = (long int) D.6277;
  D.6279 = __builtin_expect (D.6278, 0);
  if (D.6279 != 0) goto <D.6280>; else goto <D.6281>;
  <D.6280>:
  GC_clear (&GC_allocate_lock);
  D.6283 = GC_generic_malloc (lb, 0);
  D.6282 = GC_clear_stack (D.6283);
  return D.6282;
  <D.6281>:
  D.6284 = MEM[(char * *)op];
  *opp = D.6284;
  D.6285 = GC_arrays._words_allocd;
  D.6286 = D.6285 + lw;
  GC_arrays._words_allocd = D.6286;
  GC_clear (&GC_allocate_lock);
  D.6282 = op;
  return D.6282;
  <D.6272>:
  D.6287 = GC_generic_malloc (lb, 0);
  D.6282 = GC_clear_stack (D.6287);
  return D.6282;
}


GC_malloc (size_t lb)
{
  int GC_all_interior_pointers.12;
  long unsigned int D.6290;
  long unsigned int D.6291;
  _Bool D.6292;
  long int D.6293;
  long int D.6294;
  unsigned int D.6297;
  int D.6298;
  _Bool D.6301;
  long int D.6302;
  long int D.6303;
  void * D.6306;
  char * D.6307;
  char * D.6308;
  long unsigned int D.6309;
  long unsigned int D.6310;
  char * D.6311;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.12 = GC_all_interior_pointers;
  D.6290 = (long unsigned int) GC_all_interior_pointers.12;
  D.6291 = 2048 - D.6290;
  D.6292 = D.6291 >= lb;
  D.6293 = (long int) D.6292;
  D.6294 = __builtin_expect (D.6293, 1);
  if (D.6294 != 0) goto <D.6295>; else goto <D.6296>;
  <D.6295>:
  D.6297 = GC_arrays._size_map[lb];
  lw = (word) D.6297;
  opp = &GC_arrays._objfreelist[lw];
  D.6298 = GC_test_and_set (&GC_allocate_lock);
  if (D.6298 != 0) goto <D.6299>; else goto <D.6300>;
  <D.6299>:
  GC_lock ();
  <D.6300>:
  op = *opp;
  D.6301 = op == 0B;
  D.6302 = (long int) D.6301;
  D.6303 = __builtin_expect (D.6302, 0);
  if (D.6303 != 0) goto <D.6304>; else goto <D.6305>;
  <D.6304>:
  GC_clear (&GC_allocate_lock);
  D.6307 = GC_generic_malloc (lb, 1);
  D.6306 = GC_clear_stack (D.6307);
  return D.6306;
  <D.6305>:
  D.6308 = MEM[(char * *)op];
  *opp = D.6308;
  MEM[(char * *)op] = 0B;
  D.6309 = GC_arrays._words_allocd;
  D.6310 = D.6309 + lw;
  GC_arrays._words_allocd = D.6310;
  GC_clear (&GC_allocate_lock);
  D.6306 = op;
  return D.6306;
  <D.6296>:
  D.6311 = GC_generic_malloc (lb, 1);
  D.6306 = GC_clear_stack (D.6311);
  return D.6306;
}


GC_free (void * p)
{
  long unsigned int p.13;
  long unsigned int D.6316;
  unsigned char D.6317;
  long unsigned int D.6318;
  long unsigned int sz.14;
  _Bool D.6320;
  long int D.6321;
  long int D.6322;
  int D.6325;
  long unsigned int D.6328;
  long unsigned int D.6329;
  int D.6330;
  long unsigned int GC_non_gc_bytes.15;
  long int D.6334;
  long unsigned int D.6335;
  long unsigned int GC_non_gc_bytes.16;
  int D.6337;
  void * D.6340;
  long int D.6341;
  long int D.6342;
  long unsigned int D.6343;
  char * * D.6344;
  long unsigned int D.6345;
  char * D.6346;
  int D.6348;
  register struct hblk * h;
  register struct hdr * hhdr;
  register signed_word sz;
  register char * * flh;
  register int knd;
  register struct obj_kind * ok;

  if (p == 0B) goto <D.6313>; else goto <D.6314>;
  <D.6313>:
  return;
  <D.6314>:
  p.13 = (long unsigned int) p;
  D.6316 = p.13 & 18446744073709547520;
  h = (struct hblk *) D.6316;
  hhdr = GC_find_header (h);
  D.6317 = hhdr->hb_obj_kind;
  knd = (int) D.6317;
  D.6318 = hhdr->hb_sz;
  sz = (signed_word) D.6318;
  ok = &GC_obj_kinds[knd];
  sz.14 = (long unsigned int) sz;
  D.6320 = sz.14 <= 256;
  D.6321 = (long int) D.6320;
  D.6322 = __builtin_expect (D.6321, 1);
  if (D.6322 != 0) goto <D.6323>; else goto <D.6324>;
  <D.6323>:
  D.6325 = GC_test_and_set (&GC_allocate_lock);
  if (D.6325 != 0) goto <D.6326>; else goto <D.6327>;
  <D.6326>:
  GC_lock ();
  <D.6327>:
  D.6328 = GC_arrays._mem_freed;
  sz.14 = (long unsigned int) sz;
  D.6329 = D.6328 + sz.14;
  GC_arrays._mem_freed = D.6329;
  D.6330 = knd & -2;
  if (D.6330 == 2) goto <D.6331>; else goto <D.6332>;
  <D.6331>:
  GC_non_gc_bytes.15 = GC_non_gc_bytes;
  D.6334 = sz << 3;
  D.6335 = (long unsigned int) D.6334;
  GC_non_gc_bytes.16 = GC_non_gc_bytes.15 - D.6335;
  GC_non_gc_bytes = GC_non_gc_bytes.16;
  <D.6332>:
  D.6337 = ok->ok_init;
  if (D.6337 != 0) goto <D.6338>; else goto <D.6339>;
  <D.6338>:
  D.6340 = p + 8;
  D.6341 = sz + -1;
  D.6342 = D.6341 << 3;
  D.6343 = (long unsigned int) D.6342;
  memset (D.6340, 0, D.6343);
  <D.6339>:
  D.6344 = ok->ok_freelist;
  sz.14 = (long unsigned int) sz;
  D.6345 = sz.14 * 8;
  flh = D.6344 + D.6345;
  D.6346 = *flh;
  MEM[(char * *)p] = D.6346;
  *flh = p;
  GC_clear (&GC_allocate_lock);
  goto <D.6347>;
  <D.6324>:
  D.6348 = GC_test_and_set (&GC_allocate_lock);
  if (D.6348 != 0) goto <D.6349>; else goto <D.6350>;
  <D.6349>:
  GC_lock ();
  <D.6350>:
  D.6328 = GC_arrays._mem_freed;
  sz.14 = (long unsigned int) sz;
  D.6329 = D.6328 + sz.14;
  GC_arrays._mem_freed = D.6329;
  D.6330 = knd & -2;
  if (D.6330 == 2) goto <D.6351>; else goto <D.6352>;
  <D.6351>:
  GC_non_gc_bytes.15 = GC_non_gc_bytes;
  D.6334 = sz << 3;
  D.6335 = (long unsigned int) D.6334;
  GC_non_gc_bytes.16 = GC_non_gc_bytes.15 - D.6335;
  GC_non_gc_bytes = GC_non_gc_bytes.16;
  <D.6352>:
  GC_freehblk (h);
  GC_clear (&GC_allocate_lock);
  <D.6347>:
}


GC_free_inner (void * p)
{
  long unsigned int p.17;
  long unsigned int D.6355;
  unsigned char D.6356;
  long unsigned int D.6357;
  long unsigned int sz.18;
  long unsigned int D.6361;
  long unsigned int D.6362;
  int D.6363;
  long unsigned int GC_non_gc_bytes.19;
  long int D.6367;
  long unsigned int D.6368;
  long unsigned int GC_non_gc_bytes.20;
  int D.6370;
  void * D.6373;
  long int D.6374;
  long int D.6375;
  long unsigned int D.6376;
  char * * D.6377;
  long unsigned int D.6378;
  char * D.6379;
  register struct hblk * h;
  register struct hdr * hhdr;
  register signed_word sz;
  register char * * flh;
  register int knd;
  register struct obj_kind * ok;

  p.17 = (long unsigned int) p;
  D.6355 = p.17 & 18446744073709547520;
  h = (struct hblk *) D.6355;
  hhdr = GC_find_header (h);
  D.6356 = hhdr->hb_obj_kind;
  knd = (int) D.6356;
  D.6357 = hhdr->hb_sz;
  sz = (signed_word) D.6357;
  ok = &GC_obj_kinds[knd];
  sz.18 = (long unsigned int) sz;
  if (sz.18 <= 256) goto <D.6359>; else goto <D.6360>;
  <D.6359>:
  D.6361 = GC_arrays._mem_freed;
  sz.18 = (long unsigned int) sz;
  D.6362 = D.6361 + sz.18;
  GC_arrays._mem_freed = D.6362;
  D.6363 = knd & -2;
  if (D.6363 == 2) goto <D.6364>; else goto <D.6365>;
  <D.6364>:
  GC_non_gc_bytes.19 = GC_non_gc_bytes;
  D.6367 = sz << 3;
  D.6368 = (long unsigned int) D.6367;
  GC_non_gc_bytes.20 = GC_non_gc_bytes.19 - D.6368;
  GC_non_gc_bytes = GC_non_gc_bytes.20;
  <D.6365>:
  D.6370 = ok->ok_init;
  if (D.6370 != 0) goto <D.6371>; else goto <D.6372>;
  <D.6371>:
  D.6373 = p + 8;
  D.6374 = sz + -1;
  D.6375 = D.6374 << 3;
  D.6376 = (long unsigned int) D.6375;
  memset (D.6373, 0, D.6376);
  <D.6372>:
  D.6377 = ok->ok_freelist;
  sz.18 = (long unsigned int) sz;
  D.6378 = sz.18 * 8;
  flh = D.6377 + D.6378;
  D.6379 = *flh;
  MEM[(char * *)p] = D.6379;
  *flh = p;
  goto <D.6380>;
  <D.6360>:
  D.6361 = GC_arrays._mem_freed;
  sz.18 = (long unsigned int) sz;
  D.6362 = D.6361 + sz.18;
  GC_arrays._mem_freed = D.6362;
  D.6363 = knd & -2;
  if (D.6363 == 2) goto <D.6381>; else goto <D.6382>;
  <D.6381>:
  GC_non_gc_bytes.19 = GC_non_gc_bytes;
  D.6367 = sz << 3;
  D.6368 = (long unsigned int) D.6367;
  GC_non_gc_bytes.20 = GC_non_gc_bytes.19 - D.6368;
  GC_non_gc_bytes = GC_non_gc_bytes.20;
  <D.6382>:
  GC_freehblk (h);
  <D.6380>:
}