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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.5622;
  int D.5627;
  void * D.5629;
  long unsigned int D.5630;

  D.5622 = __builtin_constant_p (__len);
  if (D.5622 != 0) goto <D.5623>; else goto <D.5624>;
  <D.5623>:
  if (__len == 0) goto <D.5625>; else goto <D.5626>;
  <D.5625>:
  D.5627 = __builtin_constant_p (__ch);
  if (D.5627 == 0) goto <D.5620>; else goto <D.5628>;
  <D.5628>:
  if (__ch != 0) goto <D.5620>; else goto <D.5621>;
  <D.5620>:
  __warn_memset_zero_len ();
  D.5629 = __dest;
  return D.5629;
  <D.5621>:
  <D.5626>:
  <D.5624>:
  D.5630 = __builtin_object_size (__dest, 0);
  D.5629 = __builtin___memset_chk (__dest, __ch, __len, D.5630);
  return D.5629;
}


GC_alloc_large (word lw, int k, unsigned int flags)
{
  long unsigned int D.5632;
  long unsigned int D.5633;
  int GC_is_initialized.0;
  int GC_incremental.1;
  int GC_dont_gc.2;
  int D.5643;
  _Bool D.5647;
  int D.5648;
  int D.5649;
  unsigned int D.5653;
  unsigned int D.5654;
  long unsigned int D.5657;
  long unsigned int D.5658;
  long unsigned int D.5659;
  long unsigned int D.5660;
  long unsigned int D.5663;
  int D.5664;
  long unsigned int D.5665;
  long unsigned int D.5666;
  long unsigned int D.5667;
  char * D.5668;
  struct hblk * h;
  word n_blocks;
  char * result;

  D.5632 = lw << 3;
  D.5633 = D.5632 + 4095;
  n_blocks = D.5633 >> 12;
  GC_is_initialized.0 = GC_is_initialized;
  if (GC_is_initialized.0 == 0) goto <D.5635>; else goto <D.5636>;
  <D.5635>:
  GC_init_inner ();
  <D.5636>:
  GC_incremental.1 = GC_incremental;
  if (GC_incremental.1 != 0) goto <D.5638>; else goto <D.5639>;
  <D.5638>:
  GC_dont_gc.2 = GC_dont_gc;
  if (GC_dont_gc.2 == 0) goto <D.5641>; else goto <D.5642>;
  <D.5641>:
  D.5643 = (int) n_blocks;
  GC_collect_a_little_inner (D.5643);
  <D.5642>:
  <D.5639>:
  h = GC_allochblk (lw, k, flags);
  if (h == 0B) goto <D.5644>; else goto <D.5645>;
  <D.5644>:
  GC_merge_unmapped ();
  h = GC_allochblk (lw, k, flags);
  <D.5645>:
  goto <D.5552>;
  <D.5551>:
  h = GC_allochblk (lw, k, flags);
  <D.5552>:
  if (h == 0B) goto <D.5646>; else goto <D.5553>;
  <D.5646>:
  D.5647 = flags != 0;
  D.5648 = (int) D.5647;
  D.5649 = GC_collect_or_expand (n_blocks, D.5648);
  if (D.5649 != 0) goto <D.5551>; else goto <D.5553>;
  <D.5553>:
  if (h == 0B) goto <D.5650>; else goto <D.5651>;
  <D.5650>:
  result = 0B;
  goto <D.5652>;
  <D.5651>:
  {
    int total_bytes;

    D.5653 = (unsigned int) n_blocks;
    D.5654 = D.5653 * 4096;
    total_bytes = (int) D.5654;
    if (n_blocks > 1) goto <D.5655>; else goto <D.5656>;
    <D.5655>:
    D.5657 = GC_arrays._large_allocd_bytes;
    D.5658 = (long unsigned int) total_bytes;
    D.5659 = D.5657 + D.5658;
    GC_arrays._large_allocd_bytes = D.5659;
    D.5657 = GC_arrays._large_allocd_bytes;
    D.5660 = GC_arrays._max_large_allocd_bytes;
    if (D.5657 > D.5660) goto <D.5661>; else goto <D.5662>;
    <D.5661>:
    D.5657 = GC_arrays._large_allocd_bytes;
    GC_arrays._max_large_allocd_bytes = D.5657;
    <D.5662>:
    <D.5656>:
    result = &h->hb_body;
    D.5663 = GC_arrays._words_wasted;
    D.5664 = total_bytes >> 3;
    D.5665 = (long unsigned int) D.5664;
    D.5666 = D.5665 - lw;
    D.5667 = D.5663 + D.5666;
    GC_arrays._words_wasted = D.5667;
  }
  <D.5652>:
  D.5668 = result;
  return D.5668;
}


GC_alloc_large_and_clear (word lw, int k, unsigned int flags)
{
  long unsigned int D.5670;
  long unsigned int D.5671;
  char * D.5674;
  int GC_debugging_started.3;
  int D.5679;
  long unsigned int D.5680;
  char * result;
  word n_blocks;

  result = GC_alloc_large (lw, k, flags);
  D.5670 = lw << 3;
  D.5671 = D.5670 + 4095;
  n_blocks = D.5671 >> 12;
  if (result == 0B) goto <D.5672>; else goto <D.5673>;
  <D.5672>:
  D.5674 = 0B;
  return D.5674;
  <D.5673>:
  GC_debugging_started.3 = GC_debugging_started;
  if (GC_debugging_started.3 != 0) goto <D.5675>; else goto <D.5678>;
  <D.5678>:
  D.5679 = GC_obj_kinds[k].ok_init;
  if (D.5679 != 0) goto <D.5675>; else goto <D.5676>;
  <D.5675>:
  D.5680 = n_blocks * 4096;
  memset (result, 0, D.5680);
  <D.5676>:
  D.5674 = result;
  return D.5674;
}


GC_generic_malloc_inner (word lb, int k)
{
  int GC_all_interior_pointers.4;
  long unsigned int D.5683;
  long unsigned int D.5684;
  long unsigned int D.5687;
  long unsigned int D.5688;
  unsigned int D.5689;
  char * * D.5690;
  long unsigned int D.5691;
  int GC_is_initialized.5;
  char * D.5701;
  struct hblk * * D.5702;
  int D.5705;
  char * D.5708;
  int D.5710;
  long unsigned int D.5711;
  long unsigned int D.5712;
  long unsigned int D.5713;
  long unsigned int D.5714;
  register word lw;
  register char * op;
  register char * * opp;
  void out = <<< error >>>;

  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  D.5683 = (long unsigned int) GC_all_interior_pointers.4;
  D.5684 = 2048 - D.5683;
  if (D.5684 >= lb) goto <D.5685>; else goto <D.5686>;
  <D.5685>:
  {
    register struct obj_kind * kind;

    D.5687 = (long unsigned int) k;
    D.5688 = D.5687 * 32;
    kind = &GC_obj_kinds + D.5688;
    D.5689 = GC_arrays._size_map[lb];
    lw = (word) D.5689;
    D.5690 = kind->ok_freelist;
    D.5691 = lw * 8;
    opp = D.5690 + D.5691;
    op = *opp;
    if (op == 0B) goto <D.5692>; else goto <D.5693>;
    <D.5692>:
    D.5689 = GC_arrays._size_map[lb];
    if (D.5689 == 0) goto <D.5694>; else goto <D.5695>;
    <D.5694>:
    GC_is_initialized.5 = GC_is_initialized;
    if (GC_is_initialized.5 == 0) goto <D.5697>; else goto <D.5698>;
    <D.5697>:
    GC_init_inner ();
    <D.5698>:
    D.5689 = GC_arrays._size_map[lb];
    if (D.5689 == 0) goto <D.5699>; else goto <D.5700>;
    <D.5699>:
    GC_extend_size_map (lb);
    <D.5700>:
    D.5701 = GC_generic_malloc_inner (lb, k);
    return D.5701;
    <D.5695>:
    D.5702 = kind->ok_reclaim_list;
    if (D.5702 == 0B) goto <D.5703>; else goto <D.5704>;
    <D.5703>:
    D.5705 = GC_alloc_reclaim_list (kind);
    if (D.5705 == 0) goto out; else goto <D.5706>;
    <D.5706>:
    <D.5704>:
    op = GC_allocobj (lw, k);
    if (op == 0B) goto out; else goto <D.5707>;
    <D.5707>:
    <D.5693>:
    D.5708 = MEM[(char * *)op];
    *opp = D.5708;
    MEM[(char * *)op] = 0B;
  }
  goto <D.5709>;
  <D.5686>:
  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  D.5710 = GC_all_interior_pointers.4 + 7;
  D.5711 = (long unsigned int) D.5710;
  D.5712 = D.5711 + lb;
  lw = D.5712 >> 3;
  op = GC_alloc_large_and_clear (lw, k, 0);
  <D.5709>:
  D.5713 = GC_arrays._words_allocd;
  D.5714 = D.5713 + lw;
  GC_arrays._words_allocd = D.5714;
  out:
  D.5701 = op;
  return D.5701;
}


GC_generic_malloc_inner_ignore_off_page (size_t lb, int k)
{
  char * D.5718;
  int GC_all_interior_pointers.6;
  int D.5720;
  long unsigned int D.5721;
  long unsigned int D.5722;
  long unsigned int D.5723;
  long unsigned int D.5724;
  register word lw;
  char * op;

  if (lb <= 4096) goto <D.5716>; else goto <D.5717>;
  <D.5716>:
  D.5718 = GC_generic_malloc_inner (lb, k);
  return D.5718;
  <D.5717>:
  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  D.5720 = GC_all_interior_pointers.6 + 7;
  D.5721 = (long unsigned int) D.5720;
  D.5722 = D.5721 + lb;
  lw = D.5722 >> 3;
  op = GC_alloc_large_and_clear (lw, k, 1);
  D.5723 = GC_arrays._words_allocd;
  D.5724 = D.5723 + lw;
  GC_arrays._words_allocd = D.5724;
  D.5718 = op;
  return D.5718;
}


GC_generic_malloc (word lb, int k)
{
  int GC_have_errors.7;
  int GC_all_interior_pointers.8;
  long unsigned int D.5730;
  long unsigned int D.5731;
  int D.5734;
  int D.5738;
  long unsigned int D.5739;
  long unsigned int D.5740;
  long unsigned int D.5741;
  long unsigned int D.5742;
  int D.5743;
  int GC_debugging_started.9;
  long unsigned int D.5751;
  word * D.5753;
  long unsigned int D.5754;
  sizetype D.5755;
  word * D.5756;
  sizetype D.5757;
  word * D.5758;
  long unsigned int D.5759;
  long unsigned int D.5760;
  char * D.5769;
  void * (*<T6ee>) (size_t) GC_oom_fn.10;
  char * result;

  GC_have_errors.7 = GC_have_errors;
  if (GC_have_errors.7 != 0) goto <D.5727>; else goto <D.5728>;
  <D.5727>:
  GC_print_all_errors ();
  <D.5728>:
  GC_notify_or_invoke_finalizers ();
  GC_all_interior_pointers.8 = GC_all_interior_pointers;
  D.5730 = (long unsigned int) GC_all_interior_pointers.8;
  D.5731 = 2048 - D.5730;
  if (D.5731 >= lb) goto <D.5732>; else goto <D.5733>;
  <D.5732>:
  D.5734 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5734 != 0) goto <D.5735>; else goto <D.5736>;
  <D.5735>:
  GC_lock ();
  <D.5736>:
  result = GC_generic_malloc_inner (lb, k);
  pthread_mutex_unlock (&GC_allocate_ml);
  goto <D.5737>;
  <D.5733>:
  {
    word lw;
    word n_blocks;
    GC_bool init;

    GC_all_interior_pointers.8 = GC_all_interior_pointers;
    D.5738 = GC_all_interior_pointers.8 + 7;
    D.5739 = (long unsigned int) D.5738;
    D.5740 = D.5739 + lb;
    lw = D.5740 >> 3;
    D.5741 = lw << 3;
    D.5742 = D.5741 + 4095;
    n_blocks = D.5742 >> 12;
    init = GC_obj_kinds[k].ok_init;
    D.5743 = pthread_mutex_trylock (&GC_allocate_ml);
    if (D.5743 != 0) goto <D.5744>; else goto <D.5745>;
    <D.5744>:
    GC_lock ();
    <D.5745>:
    result = GC_alloc_large (lw, k, 0);
    if (result != 0B) goto <D.5746>; else goto <D.5747>;
    <D.5746>:
    GC_debugging_started.9 = GC_debugging_started;
    if (GC_debugging_started.9 != 0) goto <D.5749>; else goto <D.5750>;
    <D.5749>:
    D.5751 = n_blocks * 4096;
    memset (result, 0, D.5751);
    goto <D.5752>;
    <D.5750>:
    MEM[(word *)result] = 0;
    D.5753 = result + 8;
    *D.5753 = 0;
    D.5754 = lw * 8;
    D.5755 = D.5754 + 18446744073709551608;
    D.5756 = result + D.5755;
    *D.5756 = 0;
    D.5754 = lw * 8;
    D.5757 = D.5754 + 18446744073709551600;
    D.5758 = result + D.5757;
    *D.5758 = 0;
    <D.5752>:
    <D.5747>:
    D.5759 = GC_arrays._words_allocd;
    D.5760 = D.5759 + lw;
    GC_arrays._words_allocd = D.5760;
    pthread_mutex_unlock (&GC_allocate_ml);
    if (init != 0) goto <D.5761>; else goto <D.5762>;
    <D.5761>:
    GC_debugging_started.9 = GC_debugging_started;
    if (GC_debugging_started.9 == 0) goto <D.5763>; else goto <D.5764>;
    <D.5763>:
    if (result != 0B) goto <D.5765>; else goto <D.5766>;
    <D.5765>:
    D.5751 = n_blocks * 4096;
    memset (result, 0, D.5751);
    <D.5766>:
    <D.5764>:
    <D.5762>:
  }
  <D.5737>:
  if (result == 0B) goto <D.5767>; else goto <D.5768>;
  <D.5767>:
  GC_oom_fn.10 = GC_oom_fn;
  D.5769 = GC_oom_fn.10 (lb);
  return D.5769;
  <D.5768>:
  D.5769 = result;
  return D.5769;
}


GC_malloc_atomic (size_t lb)
{
  int GC_all_interior_pointers.11;
  long unsigned int D.5773;
  long unsigned int D.5774;
  _Bool D.5775;
  long int D.5776;
  long int D.5777;
  unsigned int D.5780;
  int D.5781;
  _Bool D.5784;
  long int D.5785;
  long int D.5786;
  void * D.5789;
  char * D.5790;
  char * D.5791;
  long unsigned int D.5792;
  long unsigned int D.5793;
  char * D.5794;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.11 = GC_all_interior_pointers;
  D.5773 = (long unsigned int) GC_all_interior_pointers.11;
  D.5774 = 2048 - D.5773;
  D.5775 = D.5774 >= lb;
  D.5776 = (long int) D.5775;
  D.5777 = __builtin_expect (D.5776, 1);
  if (D.5777 != 0) goto <D.5778>; else goto <D.5779>;
  <D.5778>:
  D.5780 = GC_arrays._size_map[lb];
  lw = (word) D.5780;
  opp = &GC_arrays._aobjfreelist[lw];
  D.5781 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5781 != 0) goto <D.5782>; else goto <D.5783>;
  <D.5782>:
  GC_lock ();
  <D.5783>:
  op = *opp;
  D.5784 = op == 0B;
  D.5785 = (long int) D.5784;
  D.5786 = __builtin_expect (D.5785, 0);
  if (D.5786 != 0) goto <D.5787>; else goto <D.5788>;
  <D.5787>:
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5790 = GC_generic_malloc (lb, 0);
  D.5789 = GC_clear_stack (D.5790);
  return D.5789;
  <D.5788>:
  D.5791 = MEM[(char * *)op];
  *opp = D.5791;
  D.5792 = GC_arrays._words_allocd;
  D.5793 = D.5792 + lw;
  GC_arrays._words_allocd = D.5793;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5789 = op;
  return D.5789;
  <D.5779>:
  D.5794 = GC_generic_malloc (lb, 0);
  D.5789 = GC_clear_stack (D.5794);
  return D.5789;
}


GC_malloc (size_t lb)
{
  int GC_all_interior_pointers.12;
  long unsigned int D.5797;
  long unsigned int D.5798;
  _Bool D.5799;
  long int D.5800;
  long int D.5801;
  unsigned int D.5804;
  int D.5805;
  _Bool D.5808;
  long int D.5809;
  long int D.5810;
  void * D.5813;
  char * D.5814;
  char * D.5815;
  long unsigned int D.5816;
  long unsigned int D.5817;
  char * D.5818;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.12 = GC_all_interior_pointers;
  D.5797 = (long unsigned int) GC_all_interior_pointers.12;
  D.5798 = 2048 - D.5797;
  D.5799 = D.5798 >= lb;
  D.5800 = (long int) D.5799;
  D.5801 = __builtin_expect (D.5800, 1);
  if (D.5801 != 0) goto <D.5802>; else goto <D.5803>;
  <D.5802>:
  D.5804 = GC_arrays._size_map[lb];
  lw = (word) D.5804;
  opp = &GC_arrays._objfreelist[lw];
  D.5805 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5805 != 0) goto <D.5806>; else goto <D.5807>;
  <D.5806>:
  GC_lock ();
  <D.5807>:
  op = *opp;
  D.5808 = op == 0B;
  D.5809 = (long int) D.5808;
  D.5810 = __builtin_expect (D.5809, 0);
  if (D.5810 != 0) goto <D.5811>; else goto <D.5812>;
  <D.5811>:
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5814 = GC_generic_malloc (lb, 1);
  D.5813 = GC_clear_stack (D.5814);
  return D.5813;
  <D.5812>:
  D.5815 = MEM[(char * *)op];
  *opp = D.5815;
  MEM[(char * *)op] = 0B;
  D.5816 = GC_arrays._words_allocd;
  D.5817 = D.5816 + lw;
  GC_arrays._words_allocd = D.5817;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5813 = op;
  return D.5813;
  <D.5803>:
  D.5818 = GC_generic_malloc (lb, 1);
  D.5813 = GC_clear_stack (D.5818);
  return D.5813;
}


GC_free (void * p)
{
  long unsigned int p.13;
  long unsigned int D.5823;
  unsigned char D.5824;
  long unsigned int D.5825;
  long unsigned int sz.14;
  _Bool D.5827;
  long int D.5828;
  long int D.5829;
  int D.5832;
  long unsigned int D.5835;
  long unsigned int D.5836;
  int D.5837;
  long unsigned int GC_non_gc_bytes.15;
  long int D.5841;
  long unsigned int D.5842;
  long unsigned int GC_non_gc_bytes.16;
  int D.5844;
  long int D.5847;
  long int D.5848;
  long unsigned int D.5849;
  void * D.5850;
  char * * D.5851;
  long unsigned int D.5852;
  char * D.5853;
  int D.5855;
  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.5820>; else goto <D.5821>;
  <D.5820>:
  return;
  <D.5821>:
  p.13 = (long unsigned int) p;
  D.5823 = p.13 & 18446744073709547520;
  h = (struct hblk *) D.5823;
  hhdr = GC_find_header (h);
  D.5824 = hhdr->hb_obj_kind;
  knd = (int) D.5824;
  D.5825 = hhdr->hb_sz;
  sz = (signed_word) D.5825;
  ok = &GC_obj_kinds[knd];
  sz.14 = (long unsigned int) sz;
  D.5827 = sz.14 <= 256;
  D.5828 = (long int) D.5827;
  D.5829 = __builtin_expect (D.5828, 1);
  if (D.5829 != 0) goto <D.5830>; else goto <D.5831>;
  <D.5830>:
  D.5832 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5832 != 0) goto <D.5833>; else goto <D.5834>;
  <D.5833>:
  GC_lock ();
  <D.5834>:
  D.5835 = GC_arrays._mem_freed;
  sz.14 = (long unsigned int) sz;
  D.5836 = D.5835 + sz.14;
  GC_arrays._mem_freed = D.5836;
  D.5837 = knd & -2;
  if (D.5837 == 2) goto <D.5838>; else goto <D.5839>;
  <D.5838>:
  GC_non_gc_bytes.15 = GC_non_gc_bytes;
  D.5841 = sz << 3;
  D.5842 = (long unsigned int) D.5841;
  GC_non_gc_bytes.16 = GC_non_gc_bytes.15 - D.5842;
  GC_non_gc_bytes = GC_non_gc_bytes.16;
  <D.5839>:
  D.5844 = ok->ok_init;
  if (D.5844 != 0) goto <D.5845>; else goto <D.5846>;
  <D.5845>:
  D.5847 = sz + -1;
  D.5848 = D.5847 << 3;
  D.5849 = (long unsigned int) D.5848;
  D.5850 = p + 8;
  memset (D.5850, 0, D.5849);
  <D.5846>:
  D.5851 = ok->ok_freelist;
  sz.14 = (long unsigned int) sz;
  D.5852 = sz.14 * 8;
  flh = D.5851 + D.5852;
  D.5853 = *flh;
  MEM[(char * *)p] = D.5853;
  *flh = p;
  pthread_mutex_unlock (&GC_allocate_ml);
  goto <D.5854>;
  <D.5831>:
  D.5855 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5855 != 0) goto <D.5856>; else goto <D.5857>;
  <D.5856>:
  GC_lock ();
  <D.5857>:
  D.5835 = GC_arrays._mem_freed;
  sz.14 = (long unsigned int) sz;
  D.5836 = D.5835 + sz.14;
  GC_arrays._mem_freed = D.5836;
  D.5837 = knd & -2;
  if (D.5837 == 2) goto <D.5858>; else goto <D.5859>;
  <D.5858>:
  GC_non_gc_bytes.15 = GC_non_gc_bytes;
  D.5841 = sz << 3;
  D.5842 = (long unsigned int) D.5841;
  GC_non_gc_bytes.16 = GC_non_gc_bytes.15 - D.5842;
  GC_non_gc_bytes = GC_non_gc_bytes.16;
  <D.5859>:
  GC_freehblk (h);
  pthread_mutex_unlock (&GC_allocate_ml);
  <D.5854>:
}


GC_free_inner (void * p)
{
  long unsigned int p.17;
  long unsigned int D.5862;
  unsigned char D.5863;
  long unsigned int D.5864;
  long unsigned int sz.18;
  long unsigned int D.5868;
  long unsigned int D.5869;
  int D.5870;
  long unsigned int GC_non_gc_bytes.19;
  long int D.5874;
  long unsigned int D.5875;
  long unsigned int GC_non_gc_bytes.20;
  int D.5877;
  long int D.5880;
  long int D.5881;
  long unsigned int D.5882;
  void * D.5883;
  char * * D.5884;
  long unsigned int D.5885;
  char * D.5886;
  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.5862 = p.17 & 18446744073709547520;
  h = (struct hblk *) D.5862;
  hhdr = GC_find_header (h);
  D.5863 = hhdr->hb_obj_kind;
  knd = (int) D.5863;
  D.5864 = hhdr->hb_sz;
  sz = (signed_word) D.5864;
  ok = &GC_obj_kinds[knd];
  sz.18 = (long unsigned int) sz;
  if (sz.18 <= 256) goto <D.5866>; else goto <D.5867>;
  <D.5866>:
  D.5868 = GC_arrays._mem_freed;
  sz.18 = (long unsigned int) sz;
  D.5869 = D.5868 + sz.18;
  GC_arrays._mem_freed = D.5869;
  D.5870 = knd & -2;
  if (D.5870 == 2) goto <D.5871>; else goto <D.5872>;
  <D.5871>:
  GC_non_gc_bytes.19 = GC_non_gc_bytes;
  D.5874 = sz << 3;
  D.5875 = (long unsigned int) D.5874;
  GC_non_gc_bytes.20 = GC_non_gc_bytes.19 - D.5875;
  GC_non_gc_bytes = GC_non_gc_bytes.20;
  <D.5872>:
  D.5877 = ok->ok_init;
  if (D.5877 != 0) goto <D.5878>; else goto <D.5879>;
  <D.5878>:
  D.5880 = sz + -1;
  D.5881 = D.5880 << 3;
  D.5882 = (long unsigned int) D.5881;
  D.5883 = p + 8;
  memset (D.5883, 0, D.5882);
  <D.5879>:
  D.5884 = ok->ok_freelist;
  sz.18 = (long unsigned int) sz;
  D.5885 = sz.18 * 8;
  flh = D.5884 + D.5885;
  D.5886 = *flh;
  MEM[(char * *)p] = D.5886;
  *flh = p;
  goto <D.5887>;
  <D.5867>:
  D.5868 = GC_arrays._mem_freed;
  sz.18 = (long unsigned int) sz;
  D.5869 = D.5868 + sz.18;
  GC_arrays._mem_freed = D.5869;
  D.5870 = knd & -2;
  if (D.5870 == 2) goto <D.5888>; else goto <D.5889>;
  <D.5888>:
  GC_non_gc_bytes.19 = GC_non_gc_bytes;
  D.5874 = sz << 3;
  D.5875 = (long unsigned int) D.5874;
  GC_non_gc_bytes.20 = GC_non_gc_bytes.19 - D.5875;
  GC_non_gc_bytes = GC_non_gc_bytes.20;
  <D.5889>:
  GC_freehblk (h);
  <D.5887>:
}