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

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.5702;
  long unsigned int D.5703;

  D.5703 = __builtin_object_size (__dest, 0);
  D.5702 = __builtin___memset_chk (__dest, __ch, __len, D.5703);
  return D.5702;
}


GC_alloc_large (word lw, int k, unsigned int flags)
{
  long unsigned int D.5705;
  long unsigned int D.5706;
  int GC_is_initialized.0;
  int GC_incremental.1;
  int GC_dont_gc.2;
  int D.5716;
  _Bool D.5720;
  int D.5721;
  int D.5722;
  unsigned int D.5726;
  unsigned int D.5727;
  long unsigned int D.5730;
  long unsigned int D.5731;
  long unsigned int D.5732;
  long unsigned int D.5733;
  long unsigned int D.5736;
  int D.5737;
  long unsigned int D.5738;
  long unsigned int D.5739;
  long unsigned int D.5740;
  char * D.5741;
  struct hblk * h;
  word n_blocks;
  char * result;

  D.5705 = lw << 3;
  D.5706 = D.5705 + 4095;
  n_blocks = D.5706 >> 12;
  GC_is_initialized.0 = GC_is_initialized;
  if (GC_is_initialized.0 == 0) goto <D.5708>; else goto <D.5709>;
  <D.5708>:
  GC_init_inner ();
  <D.5709>:
  GC_incremental.1 = GC_incremental;
  if (GC_incremental.1 != 0) goto <D.5711>; else goto <D.5712>;
  <D.5711>:
  GC_dont_gc.2 = GC_dont_gc;
  if (GC_dont_gc.2 == 0) goto <D.5714>; else goto <D.5715>;
  <D.5714>:
  D.5716 = (int) n_blocks;
  GC_collect_a_little_inner (D.5716);
  <D.5715>:
  <D.5712>:
  h = GC_allochblk (lw, k, flags);
  if (h == 0B) goto <D.5717>; else goto <D.5718>;
  <D.5717>:
  GC_merge_unmapped ();
  h = GC_allochblk (lw, k, flags);
  <D.5718>:
  goto <D.5634>;
  <D.5633>:
  h = GC_allochblk (lw, k, flags);
  <D.5634>:
  if (h == 0B) goto <D.5719>; else goto <D.5635>;
  <D.5719>:
  D.5720 = flags != 0;
  D.5721 = (int) D.5720;
  D.5722 = GC_collect_or_expand (n_blocks, D.5721);
  if (D.5722 != 0) goto <D.5633>; else goto <D.5635>;
  <D.5635>:
  if (h == 0B) goto <D.5723>; else goto <D.5724>;
  <D.5723>:
  result = 0B;
  goto <D.5725>;
  <D.5724>:
  {
    int total_bytes;

    D.5726 = (unsigned int) n_blocks;
    D.5727 = D.5726 * 4096;
    total_bytes = (int) D.5727;
    if (n_blocks > 1) goto <D.5728>; else goto <D.5729>;
    <D.5728>:
    D.5730 = GC_arrays._large_allocd_bytes;
    D.5731 = (long unsigned int) total_bytes;
    D.5732 = D.5730 + D.5731;
    GC_arrays._large_allocd_bytes = D.5732;
    D.5730 = GC_arrays._large_allocd_bytes;
    D.5733 = GC_arrays._max_large_allocd_bytes;
    if (D.5730 > D.5733) goto <D.5734>; else goto <D.5735>;
    <D.5734>:
    D.5730 = GC_arrays._large_allocd_bytes;
    GC_arrays._max_large_allocd_bytes = D.5730;
    <D.5735>:
    <D.5729>:
    result = &h->hb_body;
    D.5736 = GC_arrays._words_wasted;
    D.5737 = total_bytes >> 3;
    D.5738 = (long unsigned int) D.5737;
    D.5739 = D.5738 - lw;
    D.5740 = D.5736 + D.5739;
    GC_arrays._words_wasted = D.5740;
  }
  <D.5725>:
  D.5741 = result;
  return D.5741;
}


GC_alloc_large_and_clear (word lw, int k, unsigned int flags)
{
  long unsigned int D.5743;
  long unsigned int D.5744;
  char * D.5747;
  int GC_debugging_started.3;
  int D.5752;
  long unsigned int D.5753;
  char * result;
  word n_blocks;

  result = GC_alloc_large (lw, k, flags);
  D.5743 = lw << 3;
  D.5744 = D.5743 + 4095;
  n_blocks = D.5744 >> 12;
  if (result == 0B) goto <D.5745>; else goto <D.5746>;
  <D.5745>:
  D.5747 = 0B;
  return D.5747;
  <D.5746>:
  GC_debugging_started.3 = GC_debugging_started;
  if (GC_debugging_started.3 != 0) goto <D.5748>; else goto <D.5751>;
  <D.5751>:
  D.5752 = GC_obj_kinds[k].ok_init;
  if (D.5752 != 0) goto <D.5748>; else goto <D.5749>;
  <D.5748>:
  D.5753 = n_blocks * 4096;
  memset (result, 0, D.5753);
  <D.5749>:
  D.5747 = result;
  return D.5747;
}


GC_generic_malloc_inner (word lb, int k)
{
  int GC_all_interior_pointers.4;
  long unsigned int D.5756;
  long unsigned int D.5757;
  long unsigned int D.5760;
  long unsigned int D.5761;
  unsigned int D.5762;
  char * * D.5763;
  long unsigned int D.5764;
  int GC_is_initialized.5;
  char * D.5774;
  struct hblk * * D.5775;
  int D.5778;
  char * D.5781;
  int D.5783;
  long unsigned int D.5784;
  long unsigned int D.5785;
  long unsigned int D.5786;
  long unsigned int D.5787;
  register word lw;
  register char * op;
  register char * * opp;
  void out = <<< error >>>;

  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  D.5756 = (long unsigned int) GC_all_interior_pointers.4;
  D.5757 = 2048 - D.5756;
  if (D.5757 >= lb) goto <D.5758>; else goto <D.5759>;
  <D.5758>:
  {
    register struct obj_kind * kind;

    D.5760 = (long unsigned int) k;
    D.5761 = D.5760 * 32;
    kind = &GC_obj_kinds + D.5761;
    D.5762 = GC_arrays._size_map[lb];
    lw = (word) D.5762;
    D.5763 = kind->ok_freelist;
    D.5764 = lw * 8;
    opp = D.5763 + D.5764;
    op = *opp;
    if (op == 0B) goto <D.5765>; else goto <D.5766>;
    <D.5765>:
    D.5762 = GC_arrays._size_map[lb];
    if (D.5762 == 0) goto <D.5767>; else goto <D.5768>;
    <D.5767>:
    GC_is_initialized.5 = GC_is_initialized;
    if (GC_is_initialized.5 == 0) goto <D.5770>; else goto <D.5771>;
    <D.5770>:
    GC_init_inner ();
    <D.5771>:
    D.5762 = GC_arrays._size_map[lb];
    if (D.5762 == 0) goto <D.5772>; else goto <D.5773>;
    <D.5772>:
    GC_extend_size_map (lb);
    <D.5773>:
    D.5774 = GC_generic_malloc_inner (lb, k);
    return D.5774;
    <D.5768>:
    D.5775 = kind->ok_reclaim_list;
    if (D.5775 == 0B) goto <D.5776>; else goto <D.5777>;
    <D.5776>:
    D.5778 = GC_alloc_reclaim_list (kind);
    if (D.5778 == 0) goto out; else goto <D.5779>;
    <D.5779>:
    <D.5777>:
    op = GC_allocobj (lw, k);
    if (op == 0B) goto out; else goto <D.5780>;
    <D.5780>:
    <D.5766>:
    D.5781 = MEM[(char * *)op];
    *opp = D.5781;
    MEM[(char * *)op] = 0B;
  }
  goto <D.5782>;
  <D.5759>:
  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  D.5783 = GC_all_interior_pointers.4 + 7;
  D.5784 = (long unsigned int) D.5783;
  D.5785 = D.5784 + lb;
  lw = D.5785 >> 3;
  op = GC_alloc_large_and_clear (lw, k, 0);
  <D.5782>:
  D.5786 = GC_arrays._words_allocd;
  D.5787 = D.5786 + lw;
  GC_arrays._words_allocd = D.5787;
  out:
  D.5774 = op;
  return D.5774;
}


GC_generic_malloc_inner_ignore_off_page (size_t lb, int k)
{
  char * D.5791;
  int GC_all_interior_pointers.6;
  int D.5793;
  long unsigned int D.5794;
  long unsigned int D.5795;
  long unsigned int D.5796;
  long unsigned int D.5797;
  register word lw;
  char * op;

  if (lb <= 4096) goto <D.5789>; else goto <D.5790>;
  <D.5789>:
  D.5791 = GC_generic_malloc_inner (lb, k);
  return D.5791;
  <D.5790>:
  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  D.5793 = GC_all_interior_pointers.6 + 7;
  D.5794 = (long unsigned int) D.5793;
  D.5795 = D.5794 + lb;
  lw = D.5795 >> 3;
  op = GC_alloc_large_and_clear (lw, k, 1);
  D.5796 = GC_arrays._words_allocd;
  D.5797 = D.5796 + lw;
  GC_arrays._words_allocd = D.5797;
  D.5791 = op;
  return D.5791;
}


GC_generic_malloc (word lb, int k)
{
  int GC_have_errors.7;
  int GC_all_interior_pointers.8;
  long unsigned int D.5803;
  long unsigned int D.5804;
  int D.5807;
  int D.5811;
  long unsigned int D.5812;
  long unsigned int D.5813;
  long unsigned int D.5814;
  long unsigned int D.5815;
  int D.5816;
  int GC_debugging_started.9;
  long unsigned int D.5824;
  word * D.5826;
  long unsigned int D.5827;
  sizetype D.5828;
  word * D.5829;
  sizetype D.5830;
  word * D.5831;
  long unsigned int D.5832;
  long unsigned int D.5833;
  char * D.5842;
  void * (*<T764>) (size_t) GC_oom_fn.10;
  char * result;

  GC_have_errors.7 = GC_have_errors;
  if (GC_have_errors.7 != 0) goto <D.5800>; else goto <D.5801>;
  <D.5800>:
  GC_print_all_errors ();
  <D.5801>:
  GC_notify_or_invoke_finalizers ();
  GC_all_interior_pointers.8 = GC_all_interior_pointers;
  D.5803 = (long unsigned int) GC_all_interior_pointers.8;
  D.5804 = 2048 - D.5803;
  if (D.5804 >= lb) goto <D.5805>; else goto <D.5806>;
  <D.5805>:
  D.5807 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5807 != 0) goto <D.5808>; else goto <D.5809>;
  <D.5808>:
  GC_lock ();
  <D.5809>:
  result = GC_generic_malloc_inner (lb, k);
  pthread_mutex_unlock (&GC_allocate_ml);
  goto <D.5810>;
  <D.5806>:
  {
    word lw;
    word n_blocks;
    GC_bool init;

    GC_all_interior_pointers.8 = GC_all_interior_pointers;
    D.5811 = GC_all_interior_pointers.8 + 7;
    D.5812 = (long unsigned int) D.5811;
    D.5813 = D.5812 + lb;
    lw = D.5813 >> 3;
    D.5814 = lw << 3;
    D.5815 = D.5814 + 4095;
    n_blocks = D.5815 >> 12;
    init = GC_obj_kinds[k].ok_init;
    D.5816 = pthread_mutex_trylock (&GC_allocate_ml);
    if (D.5816 != 0) goto <D.5817>; else goto <D.5818>;
    <D.5817>:
    GC_lock ();
    <D.5818>:
    result = GC_alloc_large (lw, k, 0);
    if (result != 0B) goto <D.5819>; else goto <D.5820>;
    <D.5819>:
    GC_debugging_started.9 = GC_debugging_started;
    if (GC_debugging_started.9 != 0) goto <D.5822>; else goto <D.5823>;
    <D.5822>:
    D.5824 = n_blocks * 4096;
    memset (result, 0, D.5824);
    goto <D.5825>;
    <D.5823>:
    MEM[(word *)result] = 0;
    D.5826 = result + 8;
    *D.5826 = 0;
    D.5827 = lw * 8;
    D.5828 = D.5827 + 18446744073709551608;
    D.5829 = result + D.5828;
    *D.5829 = 0;
    D.5827 = lw * 8;
    D.5830 = D.5827 + 18446744073709551600;
    D.5831 = result + D.5830;
    *D.5831 = 0;
    <D.5825>:
    <D.5820>:
    D.5832 = GC_arrays._words_allocd;
    D.5833 = D.5832 + lw;
    GC_arrays._words_allocd = D.5833;
    pthread_mutex_unlock (&GC_allocate_ml);
    if (init != 0) goto <D.5834>; else goto <D.5835>;
    <D.5834>:
    GC_debugging_started.9 = GC_debugging_started;
    if (GC_debugging_started.9 == 0) goto <D.5836>; else goto <D.5837>;
    <D.5836>:
    if (result != 0B) goto <D.5838>; else goto <D.5839>;
    <D.5838>:
    D.5824 = n_blocks * 4096;
    memset (result, 0, D.5824);
    <D.5839>:
    <D.5837>:
    <D.5835>:
  }
  <D.5810>:
  if (result == 0B) goto <D.5840>; else goto <D.5841>;
  <D.5840>:
  GC_oom_fn.10 = GC_oom_fn;
  D.5842 = GC_oom_fn.10 (lb);
  return D.5842;
  <D.5841>:
  D.5842 = result;
  return D.5842;
}


GC_malloc_atomic (size_t lb)
{
  int GC_all_interior_pointers.11;
  long unsigned int D.5846;
  long unsigned int D.5847;
  _Bool D.5848;
  long int D.5849;
  long int D.5850;
  unsigned int D.5853;
  int D.5854;
  _Bool D.5857;
  long int D.5858;
  long int D.5859;
  void * D.5862;
  char * D.5863;
  char * D.5864;
  long unsigned int D.5865;
  long unsigned int D.5866;
  char * D.5867;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.11 = GC_all_interior_pointers;
  D.5846 = (long unsigned int) GC_all_interior_pointers.11;
  D.5847 = 2048 - D.5846;
  D.5848 = D.5847 >= lb;
  D.5849 = (long int) D.5848;
  D.5850 = __builtin_expect (D.5849, 1);
  if (D.5850 != 0) goto <D.5851>; else goto <D.5852>;
  <D.5851>:
  D.5853 = GC_arrays._size_map[lb];
  lw = (word) D.5853;
  opp = &GC_arrays._aobjfreelist[lw];
  D.5854 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5854 != 0) goto <D.5855>; else goto <D.5856>;
  <D.5855>:
  GC_lock ();
  <D.5856>:
  op = *opp;
  D.5857 = op == 0B;
  D.5858 = (long int) D.5857;
  D.5859 = __builtin_expect (D.5858, 0);
  if (D.5859 != 0) goto <D.5860>; else goto <D.5861>;
  <D.5860>:
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5863 = GC_generic_malloc (lb, 0);
  D.5862 = GC_clear_stack (D.5863);
  return D.5862;
  <D.5861>:
  D.5864 = MEM[(char * *)op];
  *opp = D.5864;
  D.5865 = GC_arrays._words_allocd;
  D.5866 = D.5865 + lw;
  GC_arrays._words_allocd = D.5866;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5862 = op;
  return D.5862;
  <D.5852>:
  D.5867 = GC_generic_malloc (lb, 0);
  D.5862 = GC_clear_stack (D.5867);
  return D.5862;
}


GC_malloc (size_t lb)
{
  int GC_all_interior_pointers.12;
  long unsigned int D.5870;
  long unsigned int D.5871;
  _Bool D.5872;
  long int D.5873;
  long int D.5874;
  unsigned int D.5877;
  int D.5878;
  _Bool D.5881;
  long int D.5882;
  long int D.5883;
  void * D.5886;
  char * D.5887;
  char * D.5888;
  long unsigned int D.5889;
  long unsigned int D.5890;
  char * D.5891;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.12 = GC_all_interior_pointers;
  D.5870 = (long unsigned int) GC_all_interior_pointers.12;
  D.5871 = 2048 - D.5870;
  D.5872 = D.5871 >= lb;
  D.5873 = (long int) D.5872;
  D.5874 = __builtin_expect (D.5873, 1);
  if (D.5874 != 0) goto <D.5875>; else goto <D.5876>;
  <D.5875>:
  D.5877 = GC_arrays._size_map[lb];
  lw = (word) D.5877;
  opp = &GC_arrays._objfreelist[lw];
  D.5878 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5878 != 0) goto <D.5879>; else goto <D.5880>;
  <D.5879>:
  GC_lock ();
  <D.5880>:
  op = *opp;
  D.5881 = op == 0B;
  D.5882 = (long int) D.5881;
  D.5883 = __builtin_expect (D.5882, 0);
  if (D.5883 != 0) goto <D.5884>; else goto <D.5885>;
  <D.5884>:
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5887 = GC_generic_malloc (lb, 1);
  D.5886 = GC_clear_stack (D.5887);
  return D.5886;
  <D.5885>:
  D.5888 = MEM[(char * *)op];
  *opp = D.5888;
  MEM[(char * *)op] = 0B;
  D.5889 = GC_arrays._words_allocd;
  D.5890 = D.5889 + lw;
  GC_arrays._words_allocd = D.5890;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5886 = op;
  return D.5886;
  <D.5876>:
  D.5891 = GC_generic_malloc (lb, 1);
  D.5886 = GC_clear_stack (D.5891);
  return D.5886;
}


GC_free (void * p)
{
  long unsigned int p.13;
  long unsigned int D.5896;
  unsigned char D.5897;
  long unsigned int D.5898;
  long unsigned int sz.14;
  _Bool D.5900;
  long int D.5901;
  long int D.5902;
  int D.5905;
  long unsigned int D.5908;
  long unsigned int D.5909;
  int D.5910;
  long unsigned int GC_non_gc_bytes.15;
  long int D.5914;
  long unsigned int D.5915;
  long unsigned int D.5916;
  int D.5917;
  void * D.5920;
  long int D.5921;
  long int D.5922;
  long unsigned int D.5923;
  char * * D.5924;
  long unsigned int D.5925;
  char * D.5926;
  int D.5928;
  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.5893>; else goto <D.5894>;
  <D.5893>:
  return;
  <D.5894>:
  p.13 = (long unsigned int) p;
  D.5896 = p.13 & 18446744073709547520;
  h = (struct hblk *) D.5896;
  hhdr = GC_find_header (h);
  D.5897 = hhdr->hb_obj_kind;
  knd = (int) D.5897;
  D.5898 = hhdr->hb_sz;
  sz = (signed_word) D.5898;
  ok = &GC_obj_kinds[knd];
  sz.14 = (long unsigned int) sz;
  D.5900 = sz.14 <= 256;
  D.5901 = (long int) D.5900;
  D.5902 = __builtin_expect (D.5901, 1);
  if (D.5902 != 0) goto <D.5903>; else goto <D.5904>;
  <D.5903>:
  D.5905 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5905 != 0) goto <D.5906>; else goto <D.5907>;
  <D.5906>:
  GC_lock ();
  <D.5907>:
  D.5908 = GC_arrays._mem_freed;
  sz.14 = (long unsigned int) sz;
  D.5909 = D.5908 + sz.14;
  GC_arrays._mem_freed = D.5909;
  D.5910 = knd & -2;
  if (D.5910 == 2) goto <D.5911>; else goto <D.5912>;
  <D.5911>:
  GC_non_gc_bytes.15 = GC_non_gc_bytes;
  D.5914 = sz << 3;
  D.5915 = (long unsigned int) D.5914;
  D.5916 = GC_non_gc_bytes.15 - D.5915;
  GC_non_gc_bytes = D.5916;
  <D.5912>:
  D.5917 = ok->ok_init;
  if (D.5917 != 0) goto <D.5918>; else goto <D.5919>;
  <D.5918>:
  D.5920 = p + 8;
  D.5921 = sz + -1;
  D.5922 = D.5921 << 3;
  D.5923 = (long unsigned int) D.5922;
  memset (D.5920, 0, D.5923);
  <D.5919>:
  D.5924 = ok->ok_freelist;
  sz.14 = (long unsigned int) sz;
  D.5925 = sz.14 * 8;
  flh = D.5924 + D.5925;
  D.5926 = *flh;
  MEM[(char * *)p] = D.5926;
  *flh = p;
  pthread_mutex_unlock (&GC_allocate_ml);
  goto <D.5927>;
  <D.5904>:
  D.5928 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5928 != 0) goto <D.5929>; else goto <D.5930>;
  <D.5929>:
  GC_lock ();
  <D.5930>:
  D.5908 = GC_arrays._mem_freed;
  sz.14 = (long unsigned int) sz;
  D.5909 = D.5908 + sz.14;
  GC_arrays._mem_freed = D.5909;
  D.5910 = knd & -2;
  if (D.5910 == 2) goto <D.5931>; else goto <D.5932>;
  <D.5931>:
  GC_non_gc_bytes.15 = GC_non_gc_bytes;
  D.5914 = sz << 3;
  D.5915 = (long unsigned int) D.5914;
  D.5916 = GC_non_gc_bytes.15 - D.5915;
  GC_non_gc_bytes = D.5916;
  <D.5932>:
  GC_freehblk (h);
  pthread_mutex_unlock (&GC_allocate_ml);
  <D.5927>:
}


GC_free_inner (void * p)
{
  long unsigned int p.16;
  long unsigned int D.5935;
  unsigned char D.5936;
  long unsigned int D.5937;
  long unsigned int sz.17;
  long unsigned int D.5941;
  long unsigned int D.5942;
  int D.5943;
  long unsigned int GC_non_gc_bytes.18;
  long int D.5947;
  long unsigned int D.5948;
  long unsigned int D.5949;
  int D.5950;
  void * D.5953;
  long int D.5954;
  long int D.5955;
  long unsigned int D.5956;
  char * * D.5957;
  long unsigned int D.5958;
  char * D.5959;
  register struct hblk * h;
  register struct hdr * hhdr;
  register signed_word sz;
  register char * * flh;
  register int knd;
  register struct obj_kind * ok;

  p.16 = (long unsigned int) p;
  D.5935 = p.16 & 18446744073709547520;
  h = (struct hblk *) D.5935;
  hhdr = GC_find_header (h);
  D.5936 = hhdr->hb_obj_kind;
  knd = (int) D.5936;
  D.5937 = hhdr->hb_sz;
  sz = (signed_word) D.5937;
  ok = &GC_obj_kinds[knd];
  sz.17 = (long unsigned int) sz;
  if (sz.17 <= 256) goto <D.5939>; else goto <D.5940>;
  <D.5939>:
  D.5941 = GC_arrays._mem_freed;
  sz.17 = (long unsigned int) sz;
  D.5942 = D.5941 + sz.17;
  GC_arrays._mem_freed = D.5942;
  D.5943 = knd & -2;
  if (D.5943 == 2) goto <D.5944>; else goto <D.5945>;
  <D.5944>:
  GC_non_gc_bytes.18 = GC_non_gc_bytes;
  D.5947 = sz << 3;
  D.5948 = (long unsigned int) D.5947;
  D.5949 = GC_non_gc_bytes.18 - D.5948;
  GC_non_gc_bytes = D.5949;
  <D.5945>:
  D.5950 = ok->ok_init;
  if (D.5950 != 0) goto <D.5951>; else goto <D.5952>;
  <D.5951>:
  D.5953 = p + 8;
  D.5954 = sz + -1;
  D.5955 = D.5954 << 3;
  D.5956 = (long unsigned int) D.5955;
  memset (D.5953, 0, D.5956);
  <D.5952>:
  D.5957 = ok->ok_freelist;
  sz.17 = (long unsigned int) sz;
  D.5958 = sz.17 * 8;
  flh = D.5957 + D.5958;
  D.5959 = *flh;
  MEM[(char * *)p] = D.5959;
  *flh = p;
  goto <D.5960>;
  <D.5940>:
  D.5941 = GC_arrays._mem_freed;
  sz.17 = (long unsigned int) sz;
  D.5942 = D.5941 + sz.17;
  GC_arrays._mem_freed = D.5942;
  D.5943 = knd & -2;
  if (D.5943 == 2) goto <D.5961>; else goto <D.5962>;
  <D.5961>:
  GC_non_gc_bytes.18 = GC_non_gc_bytes;
  D.5947 = sz << 3;
  D.5948 = (long unsigned int) D.5947;
  D.5949 = GC_non_gc_bytes.18 - D.5948;
  GC_non_gc_bytes = D.5949;
  <D.5962>:
  GC_freehblk (h);
  <D.5960>:
}