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

  result = GC_scratch_alloc (2052);
  if (result == 0B) goto <D.5266>; else goto <D.5267>;
  <D.5266>:
  D.5268 = 0;
  return D.5268;
  <D.5267>:
  memset (result, 0, 2052);
  kind->ok_reclaim_list = result;
  D.5268 = 1;
  return D.5268;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5272;
  int D.5277;
  void * D.5279;
  unsigned int D.5280;

  D.5272 = __builtin_constant_p (__len);
  if (D.5272 != 0) goto <D.5273>; else goto <D.5274>;
  <D.5273>:
  if (__len == 0) goto <D.5275>; else goto <D.5276>;
  <D.5275>:
  D.5277 = __builtin_constant_p (__ch);
  if (D.5277 == 0) goto <D.5270>; else goto <D.5278>;
  <D.5278>:
  if (__ch != 0) goto <D.5270>; else goto <D.5271>;
  <D.5270>:
  __warn_memset_zero_len ();
  D.5279 = __dest;
  return D.5279;
  <D.5271>:
  <D.5276>:
  <D.5274>:
  D.5280 = __builtin_object_size (__dest, 0);
  D.5279 = __builtin___memset_chk (__dest, __ch, __len, D.5280);
  return D.5279;
}


GC_alloc_large (word lw, int k, unsigned int flags)
{
  long unsigned int D.5282;
  long unsigned int D.5283;
  int GC_is_initialized.0;
  int GC_incremental.1;
  int GC_dont_gc.2;
  int n_blocks.3;
  _Bool D.5297;
  int D.5298;
  int D.5299;
  long unsigned int D.5303;
  long unsigned int D.5306;
  long unsigned int total_bytes.4;
  long unsigned int D.5308;
  long unsigned int D.5309;
  long unsigned int D.5312;
  int D.5313;
  long unsigned int D.5314;
  long unsigned int D.5315;
  long unsigned int D.5316;
  char * D.5317;
  struct hblk * h;
  word n_blocks;
  char * result;

  D.5282 = lw << 2;
  D.5283 = D.5282 + 4095;
  n_blocks = D.5283 >> 12;
  GC_is_initialized.0 = GC_is_initialized;
  if (GC_is_initialized.0 == 0) goto <D.5285>; else goto <D.5286>;
  <D.5285>:
  GC_init_inner ();
  <D.5286>:
  GC_incremental.1 = GC_incremental;
  if (GC_incremental.1 != 0) goto <D.5288>; else goto <D.5289>;
  <D.5288>:
  GC_dont_gc.2 = GC_dont_gc;
  if (GC_dont_gc.2 == 0) goto <D.5291>; else goto <D.5292>;
  <D.5291>:
  n_blocks.3 = (int) n_blocks;
  GC_collect_a_little_inner (n_blocks.3);
  <D.5292>:
  <D.5289>:
  h = GC_allochblk (lw, k, flags);
  if (h == 0B) goto <D.5294>; else goto <D.5295>;
  <D.5294>:
  GC_merge_unmapped ();
  h = GC_allochblk (lw, k, flags);
  <D.5295>:
  goto <D.5202>;
  <D.5201>:
  h = GC_allochblk (lw, k, flags);
  <D.5202>:
  if (h == 0B) goto <D.5296>; else goto <D.5203>;
  <D.5296>:
  D.5297 = flags != 0;
  D.5298 = (int) D.5297;
  D.5299 = GC_collect_or_expand (n_blocks, D.5298);
  if (D.5299 != 0) goto <D.5201>; else goto <D.5203>;
  <D.5203>:
  if (h == 0B) goto <D.5300>; else goto <D.5301>;
  <D.5300>:
  result = 0B;
  goto <D.5302>;
  <D.5301>:
  {
    int total_bytes;

    D.5303 = n_blocks * 4096;
    total_bytes = (int) D.5303;
    if (n_blocks > 1) goto <D.5304>; else goto <D.5305>;
    <D.5304>:
    D.5306 = GC_arrays._large_allocd_bytes;
    total_bytes.4 = (long unsigned int) total_bytes;
    D.5308 = D.5306 + total_bytes.4;
    GC_arrays._large_allocd_bytes = D.5308;
    D.5306 = GC_arrays._large_allocd_bytes;
    D.5309 = GC_arrays._max_large_allocd_bytes;
    if (D.5306 > D.5309) goto <D.5310>; else goto <D.5311>;
    <D.5310>:
    D.5306 = GC_arrays._large_allocd_bytes;
    GC_arrays._max_large_allocd_bytes = D.5306;
    <D.5311>:
    <D.5305>:
    result = &h->hb_body;
    D.5312 = GC_arrays._words_wasted;
    D.5313 = total_bytes >> 2;
    D.5314 = (long unsigned int) D.5313;
    D.5315 = D.5314 - lw;
    D.5316 = D.5312 + D.5315;
    GC_arrays._words_wasted = D.5316;
  }
  <D.5302>:
  D.5317 = result;
  return D.5317;
}


GC_alloc_large_and_clear (word lw, int k, unsigned int flags)
{
  long unsigned int D.5319;
  long unsigned int D.5320;
  char * D.5323;
  int GC_debugging_started.5;
  int D.5328;
  long unsigned int D.5329;
  char * result;
  word n_blocks;

  result = GC_alloc_large (lw, k, flags);
  D.5319 = lw << 2;
  D.5320 = D.5319 + 4095;
  n_blocks = D.5320 >> 12;
  if (result == 0B) goto <D.5321>; else goto <D.5322>;
  <D.5321>:
  D.5323 = 0B;
  return D.5323;
  <D.5322>:
  GC_debugging_started.5 = GC_debugging_started;
  if (GC_debugging_started.5 != 0) goto <D.5324>; else goto <D.5327>;
  <D.5327>:
  D.5328 = GC_obj_kinds[k].ok_init;
  if (D.5328 != 0) goto <D.5324>; else goto <D.5325>;
  <D.5324>:
  D.5329 = n_blocks * 4096;
  memset (result, 0, D.5329);
  <D.5325>:
  D.5323 = result;
  return D.5323;
}


GC_generic_malloc_inner (word lb, int k)
{
  int GC_all_interior_pointers.6;
  long unsigned int GC_all_interior_pointers.7;
  long unsigned int D.5333;
  unsigned int k.8;
  unsigned int D.5337;
  char * * D.5338;
  long unsigned int D.5339;
  unsigned int D.5342;
  int GC_is_initialized.9;
  char * D.5350;
  struct hblk * * D.5351;
  int D.5354;
  char * D.5357;
  long unsigned int D.5359;
  long unsigned int D.5360;
  long unsigned int D.5361;
  long unsigned int D.5362;
  register word lw;
  register char * op;
  register char * * opp;
  void out = <<< error >>>;

  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  GC_all_interior_pointers.7 = (long unsigned int) GC_all_interior_pointers.6;
  D.5333 = 2048 - GC_all_interior_pointers.7;
  if (D.5333 >= lb) goto <D.5334>; else goto <D.5335>;
  <D.5334>:
  {
    register struct obj_kind * kind;

    k.8 = (unsigned int) k;
    D.5337 = k.8 * 20;
    kind = &GC_obj_kinds + D.5337;
    lw = GC_arrays._size_map[lb];
    D.5338 = kind->ok_freelist;
    D.5339 = lw * 4;
    opp = D.5338 + D.5339;
    op = *opp;
    if (op == 0B) goto <D.5340>; else goto <D.5341>;
    <D.5340>:
    D.5342 = GC_arrays._size_map[lb];
    if (D.5342 == 0) goto <D.5343>; else goto <D.5344>;
    <D.5343>:
    GC_is_initialized.9 = GC_is_initialized;
    if (GC_is_initialized.9 == 0) goto <D.5346>; else goto <D.5347>;
    <D.5346>:
    GC_init_inner ();
    <D.5347>:
    D.5342 = GC_arrays._size_map[lb];
    if (D.5342 == 0) goto <D.5348>; else goto <D.5349>;
    <D.5348>:
    GC_extend_size_map (lb);
    <D.5349>:
    D.5350 = GC_generic_malloc_inner (lb, k);
    return D.5350;
    <D.5344>:
    D.5351 = kind->ok_reclaim_list;
    if (D.5351 == 0B) goto <D.5352>; else goto <D.5353>;
    <D.5352>:
    D.5354 = GC_alloc_reclaim_list (kind);
    if (D.5354 == 0) goto out; else goto <D.5355>;
    <D.5355>:
    <D.5353>:
    op = GC_allocobj (lw, k);
    if (op == 0B) goto out; else goto <D.5356>;
    <D.5356>:
    <D.5341>:
    D.5357 = MEM[(char * *)op];
    *opp = D.5357;
    MEM[(char * *)op] = 0B;
  }
  goto <D.5358>;
  <D.5335>:
  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  GC_all_interior_pointers.7 = (long unsigned int) GC_all_interior_pointers.6;
  D.5359 = GC_all_interior_pointers.7 + lb;
  D.5360 = D.5359 + 3;
  lw = D.5360 >> 2;
  op = GC_alloc_large_and_clear (lw, k, 0);
  <D.5358>:
  D.5361 = GC_arrays._words_allocd;
  D.5362 = D.5361 + lw;
  GC_arrays._words_allocd = D.5362;
  out:
  D.5350 = op;
  return D.5350;
}


GC_generic_malloc_inner_ignore_off_page (size_t lb, int k)
{
  char * D.5366;
  int GC_all_interior_pointers.10;
  unsigned int GC_all_interior_pointers.11;
  unsigned int D.5369;
  unsigned int D.5370;
  long unsigned int D.5371;
  long unsigned int D.5372;
  register word lw;
  char * op;

  if (lb <= 4096) goto <D.5364>; else goto <D.5365>;
  <D.5364>:
  D.5366 = GC_generic_malloc_inner (lb, k);
  return D.5366;
  <D.5365>:
  GC_all_interior_pointers.10 = GC_all_interior_pointers;
  GC_all_interior_pointers.11 = (unsigned int) GC_all_interior_pointers.10;
  D.5369 = GC_all_interior_pointers.11 + lb;
  D.5370 = D.5369 + 3;
  lw = D.5370 >> 2;
  op = GC_alloc_large_and_clear (lw, k, 1);
  D.5371 = GC_arrays._words_allocd;
  D.5372 = D.5371 + lw;
  GC_arrays._words_allocd = D.5372;
  D.5366 = op;
  return D.5366;
}


GC_generic_malloc (word lb, int k)
{
  int GC_have_errors.12;
  int GC_all_interior_pointers.13;
  long unsigned int GC_all_interior_pointers.14;
  long unsigned int D.5379;
  int D.5382;
  long unsigned int D.5386;
  long unsigned int D.5387;
  long unsigned int D.5388;
  long unsigned int D.5389;
  int D.5390;
  int GC_debugging_started.15;
  long unsigned int D.5398;
  word * D.5400;
  sizetype D.5401;
  sizetype D.5402;
  word * D.5403;
  sizetype D.5404;
  sizetype D.5405;
  word * D.5406;
  long unsigned int D.5407;
  long unsigned int D.5408;
  char * D.5417;
  void * (*<T633>) (size_t) GC_oom_fn.16;
  char * result;

  GC_have_errors.12 = GC_have_errors;
  if (GC_have_errors.12 != 0) goto <D.5375>; else goto <D.5376>;
  <D.5375>:
  GC_print_all_errors ();
  <D.5376>:
  GC_notify_or_invoke_finalizers ();
  GC_all_interior_pointers.13 = GC_all_interior_pointers;
  GC_all_interior_pointers.14 = (long unsigned int) GC_all_interior_pointers.13;
  D.5379 = 2048 - GC_all_interior_pointers.14;
  if (D.5379 >= lb) goto <D.5380>; else goto <D.5381>;
  <D.5380>:
  D.5382 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5382 != 0) goto <D.5383>; else goto <D.5384>;
  <D.5383>:
  GC_lock ();
  <D.5384>:
  result = GC_generic_malloc_inner (lb, k);
  pthread_mutex_unlock (&GC_allocate_ml);
  goto <D.5385>;
  <D.5381>:
  {
    word lw;
    word n_blocks;
    GC_bool init;

    GC_all_interior_pointers.13 = GC_all_interior_pointers;
    GC_all_interior_pointers.14 = (long unsigned int) GC_all_interior_pointers.13;
    D.5386 = GC_all_interior_pointers.14 + lb;
    D.5387 = D.5386 + 3;
    lw = D.5387 >> 2;
    D.5388 = lw << 2;
    D.5389 = D.5388 + 4095;
    n_blocks = D.5389 >> 12;
    init = GC_obj_kinds[k].ok_init;
    D.5390 = pthread_mutex_trylock (&GC_allocate_ml);
    if (D.5390 != 0) goto <D.5391>; else goto <D.5392>;
    <D.5391>:
    GC_lock ();
    <D.5392>:
    result = GC_alloc_large (lw, k, 0);
    if (result != 0B) goto <D.5393>; else goto <D.5394>;
    <D.5393>:
    GC_debugging_started.15 = GC_debugging_started;
    if (GC_debugging_started.15 != 0) goto <D.5396>; else goto <D.5397>;
    <D.5396>:
    D.5398 = n_blocks * 4096;
    memset (result, 0, D.5398);
    goto <D.5399>;
    <D.5397>:
    MEM[(word *)result] = 0;
    D.5400 = result + 4;
    *D.5400 = 0;
    D.5401 = lw + 1073741823;
    D.5402 = D.5401 * 4;
    D.5403 = result + D.5402;
    *D.5403 = 0;
    D.5404 = lw + 1073741822;
    D.5405 = D.5404 * 4;
    D.5406 = result + D.5405;
    *D.5406 = 0;
    <D.5399>:
    <D.5394>:
    D.5407 = GC_arrays._words_allocd;
    D.5408 = D.5407 + lw;
    GC_arrays._words_allocd = D.5408;
    pthread_mutex_unlock (&GC_allocate_ml);
    if (init != 0) goto <D.5409>; else goto <D.5410>;
    <D.5409>:
    GC_debugging_started.15 = GC_debugging_started;
    if (GC_debugging_started.15 == 0) goto <D.5411>; else goto <D.5412>;
    <D.5411>:
    if (result != 0B) goto <D.5413>; else goto <D.5414>;
    <D.5413>:
    D.5398 = n_blocks * 4096;
    memset (result, 0, D.5398);
    <D.5414>:
    <D.5412>:
    <D.5410>:
  }
  <D.5385>:
  if (result == 0B) goto <D.5415>; else goto <D.5416>;
  <D.5415>:
  GC_oom_fn.16 = GC_oom_fn;
  D.5417 = GC_oom_fn.16 (lb);
  return D.5417;
  <D.5416>:
  D.5417 = result;
  return D.5417;
}


GC_malloc_atomic (size_t lb)
{
  int GC_all_interior_pointers.17;
  long unsigned int GC_all_interior_pointers.18;
  long unsigned int D.5422;
  _Bool D.5423;
  long int D.5424;
  long int D.5425;
  int D.5428;
  _Bool D.5431;
  long int D.5432;
  long int D.5433;
  void * D.5436;
  char * D.5437;
  char * D.5438;
  long unsigned int D.5439;
  long unsigned int D.5440;
  char * D.5441;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.17 = GC_all_interior_pointers;
  GC_all_interior_pointers.18 = (long unsigned int) GC_all_interior_pointers.17;
  D.5422 = 2048 - GC_all_interior_pointers.18;
  D.5423 = D.5422 >= lb;
  D.5424 = (long int) D.5423;
  D.5425 = __builtin_expect (D.5424, 1);
  if (D.5425 != 0) goto <D.5426>; else goto <D.5427>;
  <D.5426>:
  lw = GC_arrays._size_map[lb];
  opp = &GC_arrays._aobjfreelist[lw];
  D.5428 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5428 != 0) goto <D.5429>; else goto <D.5430>;
  <D.5429>:
  GC_lock ();
  <D.5430>:
  op = *opp;
  D.5431 = op == 0B;
  D.5432 = (long int) D.5431;
  D.5433 = __builtin_expect (D.5432, 0);
  if (D.5433 != 0) goto <D.5434>; else goto <D.5435>;
  <D.5434>:
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5437 = GC_generic_malloc (lb, 0);
  D.5436 = GC_clear_stack (D.5437);
  return D.5436;
  <D.5435>:
  D.5438 = MEM[(char * *)op];
  *opp = D.5438;
  D.5439 = GC_arrays._words_allocd;
  D.5440 = D.5439 + lw;
  GC_arrays._words_allocd = D.5440;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5436 = op;
  return D.5436;
  <D.5427>:
  D.5441 = GC_generic_malloc (lb, 0);
  D.5436 = GC_clear_stack (D.5441);
  return D.5436;
}


GC_malloc (size_t lb)
{
  int GC_all_interior_pointers.19;
  long unsigned int GC_all_interior_pointers.20;
  long unsigned int D.5445;
  _Bool D.5446;
  long int D.5447;
  long int D.5448;
  int D.5451;
  _Bool D.5454;
  long int D.5455;
  long int D.5456;
  void * D.5459;
  char * D.5460;
  char * D.5461;
  long unsigned int D.5462;
  long unsigned int D.5463;
  char * D.5464;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.19 = GC_all_interior_pointers;
  GC_all_interior_pointers.20 = (long unsigned int) GC_all_interior_pointers.19;
  D.5445 = 2048 - GC_all_interior_pointers.20;
  D.5446 = D.5445 >= lb;
  D.5447 = (long int) D.5446;
  D.5448 = __builtin_expect (D.5447, 1);
  if (D.5448 != 0) goto <D.5449>; else goto <D.5450>;
  <D.5449>:
  lw = GC_arrays._size_map[lb];
  opp = &GC_arrays._objfreelist[lw];
  D.5451 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5451 != 0) goto <D.5452>; else goto <D.5453>;
  <D.5452>:
  GC_lock ();
  <D.5453>:
  op = *opp;
  D.5454 = op == 0B;
  D.5455 = (long int) D.5454;
  D.5456 = __builtin_expect (D.5455, 0);
  if (D.5456 != 0) goto <D.5457>; else goto <D.5458>;
  <D.5457>:
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5460 = GC_generic_malloc (lb, 1);
  D.5459 = GC_clear_stack (D.5460);
  return D.5459;
  <D.5458>:
  D.5461 = MEM[(char * *)op];
  *opp = D.5461;
  MEM[(char * *)op] = 0B;
  D.5462 = GC_arrays._words_allocd;
  D.5463 = D.5462 + lw;
  GC_arrays._words_allocd = D.5463;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5459 = op;
  return D.5459;
  <D.5450>:
  D.5464 = GC_generic_malloc (lb, 1);
  D.5459 = GC_clear_stack (D.5464);
  return D.5459;
}


GC_free (void * p)
{
  long unsigned int p.21;
  long unsigned int D.5469;
  long unsigned int h.22;
  long unsigned int D.5471;
  struct bottom_index * D.5472;
  long unsigned int D.5473;
  long unsigned int D.5474;
  unsigned char D.5475;
  long unsigned int D.5476;
  long unsigned int sz.23;
  _Bool D.5478;
  long int D.5479;
  long int D.5480;
  int D.5483;
  long unsigned int D.5486;
  long unsigned int D.5487;
  int D.5488;
  long unsigned int GC_non_gc_bytes.24;
  long int D.5492;
  long unsigned int D.5493;
  long unsigned int GC_non_gc_bytes.25;
  int D.5495;
  long int D.5498;
  long int D.5499;
  unsigned int D.5500;
  void * D.5501;
  char * * D.5502;
  unsigned int sz.26;
  unsigned int D.5504;
  char * D.5505;
  int D.5507;
  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.5466>; else goto <D.5467>;
  <D.5466>:
  return;
  <D.5467>:
  p.21 = (long unsigned int) p;
  D.5469 = p.21 & 4294963200;
  h = (struct hblk *) D.5469;
  h.22 = (long unsigned int) h;
  D.5471 = h.22 >> 22;
  D.5472 = GC_arrays._top_index[D.5471];
  h.22 = (long unsigned int) h;
  D.5473 = h.22 >> 12;
  D.5474 = D.5473 & 1023;
  hhdr = D.5472->index[D.5474];
  D.5475 = hhdr->hb_obj_kind;
  knd = (int) D.5475;
  D.5476 = hhdr->hb_sz;
  sz = (signed_word) D.5476;
  ok = &GC_obj_kinds[knd];
  sz.23 = (long unsigned int) sz;
  D.5478 = sz.23 <= 512;
  D.5479 = (long int) D.5478;
  D.5480 = __builtin_expect (D.5479, 1);
  if (D.5480 != 0) goto <D.5481>; else goto <D.5482>;
  <D.5481>:
  D.5483 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5483 != 0) goto <D.5484>; else goto <D.5485>;
  <D.5484>:
  GC_lock ();
  <D.5485>:
  D.5486 = GC_arrays._mem_freed;
  sz.23 = (long unsigned int) sz;
  D.5487 = D.5486 + sz.23;
  GC_arrays._mem_freed = D.5487;
  D.5488 = knd & -2;
  if (D.5488 == 2) goto <D.5489>; else goto <D.5490>;
  <D.5489>:
  GC_non_gc_bytes.24 = GC_non_gc_bytes;
  D.5492 = sz << 2;
  D.5493 = (long unsigned int) D.5492;
  GC_non_gc_bytes.25 = GC_non_gc_bytes.24 - D.5493;
  GC_non_gc_bytes = GC_non_gc_bytes.25;
  <D.5490>:
  D.5495 = ok->ok_init;
  if (D.5495 != 0) goto <D.5496>; else goto <D.5497>;
  <D.5496>:
  D.5498 = sz + -1;
  D.5499 = D.5498 << 2;
  D.5500 = (unsigned int) D.5499;
  D.5501 = p + 4;
  memset (D.5501, 0, D.5500);
  <D.5497>:
  D.5502 = ok->ok_freelist;
  sz.26 = (unsigned int) sz;
  D.5504 = sz.26 * 4;
  flh = D.5502 + D.5504;
  D.5505 = *flh;
  MEM[(char * *)p] = D.5505;
  *flh = p;
  pthread_mutex_unlock (&GC_allocate_ml);
  goto <D.5506>;
  <D.5482>:
  D.5507 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5507 != 0) goto <D.5508>; else goto <D.5509>;
  <D.5508>:
  GC_lock ();
  <D.5509>:
  D.5486 = GC_arrays._mem_freed;
  sz.23 = (long unsigned int) sz;
  D.5487 = D.5486 + sz.23;
  GC_arrays._mem_freed = D.5487;
  D.5488 = knd & -2;
  if (D.5488 == 2) goto <D.5510>; else goto <D.5511>;
  <D.5510>:
  GC_non_gc_bytes.24 = GC_non_gc_bytes;
  D.5492 = sz << 2;
  D.5493 = (long unsigned int) D.5492;
  GC_non_gc_bytes.25 = GC_non_gc_bytes.24 - D.5493;
  GC_non_gc_bytes = GC_non_gc_bytes.25;
  <D.5511>:
  GC_freehblk (h);
  pthread_mutex_unlock (&GC_allocate_ml);
  <D.5506>:
}


GC_free_inner (void * p)
{
  long unsigned int p.27;
  long unsigned int D.5514;
  long unsigned int h.28;
  long unsigned int D.5516;
  struct bottom_index * D.5517;
  long unsigned int D.5518;
  long unsigned int D.5519;
  unsigned char D.5520;
  long unsigned int D.5521;
  long unsigned int sz.29;
  long unsigned int D.5525;
  long unsigned int D.5526;
  int D.5527;
  long unsigned int GC_non_gc_bytes.30;
  long int D.5531;
  long unsigned int D.5532;
  long unsigned int GC_non_gc_bytes.31;
  int D.5534;
  long int D.5537;
  long int D.5538;
  unsigned int D.5539;
  void * D.5540;
  char * * D.5541;
  unsigned int sz.32;
  unsigned int D.5543;
  char * D.5544;
  register struct hblk * h;
  register struct hdr * hhdr;
  register signed_word sz;
  register char * * flh;
  register int knd;
  register struct obj_kind * ok;

  p.27 = (long unsigned int) p;
  D.5514 = p.27 & 4294963200;
  h = (struct hblk *) D.5514;
  h.28 = (long unsigned int) h;
  D.5516 = h.28 >> 22;
  D.5517 = GC_arrays._top_index[D.5516];
  h.28 = (long unsigned int) h;
  D.5518 = h.28 >> 12;
  D.5519 = D.5518 & 1023;
  hhdr = D.5517->index[D.5519];
  D.5520 = hhdr->hb_obj_kind;
  knd = (int) D.5520;
  D.5521 = hhdr->hb_sz;
  sz = (signed_word) D.5521;
  ok = &GC_obj_kinds[knd];
  sz.29 = (long unsigned int) sz;
  if (sz.29 <= 512) goto <D.5523>; else goto <D.5524>;
  <D.5523>:
  D.5525 = GC_arrays._mem_freed;
  sz.29 = (long unsigned int) sz;
  D.5526 = D.5525 + sz.29;
  GC_arrays._mem_freed = D.5526;
  D.5527 = knd & -2;
  if (D.5527 == 2) goto <D.5528>; else goto <D.5529>;
  <D.5528>:
  GC_non_gc_bytes.30 = GC_non_gc_bytes;
  D.5531 = sz << 2;
  D.5532 = (long unsigned int) D.5531;
  GC_non_gc_bytes.31 = GC_non_gc_bytes.30 - D.5532;
  GC_non_gc_bytes = GC_non_gc_bytes.31;
  <D.5529>:
  D.5534 = ok->ok_init;
  if (D.5534 != 0) goto <D.5535>; else goto <D.5536>;
  <D.5535>:
  D.5537 = sz + -1;
  D.5538 = D.5537 << 2;
  D.5539 = (unsigned int) D.5538;
  D.5540 = p + 4;
  memset (D.5540, 0, D.5539);
  <D.5536>:
  D.5541 = ok->ok_freelist;
  sz.32 = (unsigned int) sz;
  D.5543 = sz.32 * 4;
  flh = D.5541 + D.5543;
  D.5544 = *flh;
  MEM[(char * *)p] = D.5544;
  *flh = p;
  goto <D.5545>;
  <D.5524>:
  D.5525 = GC_arrays._mem_freed;
  sz.29 = (long unsigned int) sz;
  D.5526 = D.5525 + sz.29;
  GC_arrays._mem_freed = D.5526;
  D.5527 = knd & -2;
  if (D.5527 == 2) goto <D.5546>; else goto <D.5547>;
  <D.5546>:
  GC_non_gc_bytes.30 = GC_non_gc_bytes;
  D.5531 = sz << 2;
  D.5532 = (long unsigned int) D.5531;
  GC_non_gc_bytes.31 = GC_non_gc_bytes.30 - D.5532;
  GC_non_gc_bytes = GC_non_gc_bytes.31;
  <D.5547>:
  GC_freehblk (h);
  <D.5545>:
}