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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.7785;
  int D.7790;
  void * D.7792;
  unsigned int D.7793;

  D.7785 = __builtin_constant_p (__len);
  if (D.7785 != 0) goto <D.7786>; else goto <D.7787>;
  <D.7786>:
  if (__len == 0) goto <D.7788>; else goto <D.7789>;
  <D.7788>:
  D.7790 = __builtin_constant_p (__ch);
  if (D.7790 == 0) goto <D.7783>; else goto <D.7791>;
  <D.7791>:
  if (__ch != 0) goto <D.7783>; else goto <D.7784>;
  <D.7783>:
  __warn_memset_zero_len ();
  D.7792 = __dest;
  return D.7792;
  <D.7784>:
  <D.7789>:
  <D.7787>:
  D.7793 = __builtin_object_size (__dest, 0);
  D.7792 = __builtin___memset_chk (__dest, __ch, __len, D.7793);
  return D.7792;
}


GC_alloc_large (word lw, int k, unsigned int flags)
{
  long unsigned int D.7795;
  long unsigned int D.7796;
  int GC_is_initialized.0;
  int GC_incremental.1;
  int GC_dont_gc.2;
  int n_blocks.3;
  _Bool D.7810;
  int D.7811;
  int D.7812;
  long unsigned int D.7816;
  long unsigned int D.7819;
  long unsigned int total_bytes.4;
  long unsigned int D.7821;
  long unsigned int D.7822;
  long unsigned int D.7825;
  int D.7826;
  long unsigned int D.7827;
  long unsigned int D.7828;
  long unsigned int D.7829;
  char * D.7830;
  struct hblk * h;
  word n_blocks;
  char * result;

  D.7795 = lw << 2;
  D.7796 = D.7795 + 4095;
  n_blocks = D.7796 >> 12;
  GC_is_initialized.0 = GC_is_initialized;
  if (GC_is_initialized.0 == 0) goto <D.7798>; else goto <D.7799>;
  <D.7798>:
  GC_init_inner ();
  <D.7799>:
  GC_incremental.1 = GC_incremental;
  if (GC_incremental.1 != 0) goto <D.7801>; else goto <D.7802>;
  <D.7801>:
  GC_dont_gc.2 = GC_dont_gc;
  if (GC_dont_gc.2 == 0) goto <D.7804>; else goto <D.7805>;
  <D.7804>:
  n_blocks.3 = (int) n_blocks;
  GC_collect_a_little_inner (n_blocks.3);
  <D.7805>:
  <D.7802>:
  h = GC_allochblk (lw, k, flags);
  if (h == 0B) goto <D.7807>; else goto <D.7808>;
  <D.7807>:
  GC_merge_unmapped ();
  h = GC_allochblk (lw, k, flags);
  <D.7808>:
  goto <D.7713>;
  <D.7712>:
  h = GC_allochblk (lw, k, flags);
  <D.7713>:
  if (h == 0B) goto <D.7809>; else goto <D.7714>;
  <D.7809>:
  D.7810 = flags != 0;
  D.7811 = (int) D.7810;
  D.7812 = GC_collect_or_expand (n_blocks, D.7811);
  if (D.7812 != 0) goto <D.7712>; else goto <D.7714>;
  <D.7714>:
  if (h == 0B) goto <D.7813>; else goto <D.7814>;
  <D.7813>:
  result = 0B;
  goto <D.7815>;
  <D.7814>:
  {
    int total_bytes;

    D.7816 = n_blocks * 4096;
    total_bytes = (int) D.7816;
    if (n_blocks > 1) goto <D.7817>; else goto <D.7818>;
    <D.7817>:
    D.7819 = GC_arrays._large_allocd_bytes;
    total_bytes.4 = (long unsigned int) total_bytes;
    D.7821 = D.7819 + total_bytes.4;
    GC_arrays._large_allocd_bytes = D.7821;
    D.7819 = GC_arrays._large_allocd_bytes;
    D.7822 = GC_arrays._max_large_allocd_bytes;
    if (D.7819 > D.7822) goto <D.7823>; else goto <D.7824>;
    <D.7823>:
    D.7819 = GC_arrays._large_allocd_bytes;
    GC_arrays._max_large_allocd_bytes = D.7819;
    <D.7824>:
    <D.7818>:
    result = &h->hb_body;
    D.7825 = GC_arrays._words_wasted;
    D.7826 = total_bytes >> 2;
    D.7827 = (long unsigned int) D.7826;
    D.7828 = D.7827 - lw;
    D.7829 = D.7825 + D.7828;
    GC_arrays._words_wasted = D.7829;
  }
  <D.7815>:
  D.7830 = result;
  return D.7830;
}


GC_alloc_large_and_clear (word lw, int k, unsigned int flags)
{
  long unsigned int D.7832;
  long unsigned int D.7833;
  char * D.7836;
  int GC_debugging_started.5;
  int D.7841;
  long unsigned int D.7842;
  char * result;
  word n_blocks;

  result = GC_alloc_large (lw, k, flags);
  D.7832 = lw << 2;
  D.7833 = D.7832 + 4095;
  n_blocks = D.7833 >> 12;
  if (result == 0B) goto <D.7834>; else goto <D.7835>;
  <D.7834>:
  D.7836 = 0B;
  return D.7836;
  <D.7835>:
  GC_debugging_started.5 = GC_debugging_started;
  if (GC_debugging_started.5 != 0) goto <D.7837>; else goto <D.7840>;
  <D.7840>:
  D.7841 = GC_obj_kinds[k].ok_init;
  if (D.7841 != 0) goto <D.7837>; else goto <D.7838>;
  <D.7837>:
  D.7842 = n_blocks * 4096;
  memset (result, 0, D.7842);
  <D.7838>:
  D.7836 = result;
  return D.7836;
}


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.7846;
  unsigned int k.8;
  unsigned int D.7850;
  char * * D.7851;
  long unsigned int D.7852;
  unsigned int D.7855;
  int GC_is_initialized.9;
  char * D.7863;
  struct hblk * * D.7864;
  int D.7867;
  char * D.7870;
  long unsigned int D.7872;
  long unsigned int D.7873;
  long unsigned int D.7874;
  long unsigned int D.7875;
  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.7846 = 2048 - GC_all_interior_pointers.7;
  if (D.7846 >= lb) goto <D.7847>; else goto <D.7848>;
  <D.7847>:
  {
    register struct obj_kind * kind;

    k.8 = (unsigned int) k;
    D.7850 = k.8 * 20;
    kind = &GC_obj_kinds + D.7850;
    lw = GC_arrays._size_map[lb];
    D.7851 = kind->ok_freelist;
    D.7852 = lw * 4;
    opp = D.7851 + D.7852;
    op = *opp;
    if (op == 0B) goto <D.7853>; else goto <D.7854>;
    <D.7853>:
    D.7855 = GC_arrays._size_map[lb];
    if (D.7855 == 0) goto <D.7856>; else goto <D.7857>;
    <D.7856>:
    GC_is_initialized.9 = GC_is_initialized;
    if (GC_is_initialized.9 == 0) goto <D.7859>; else goto <D.7860>;
    <D.7859>:
    GC_init_inner ();
    <D.7860>:
    D.7855 = GC_arrays._size_map[lb];
    if (D.7855 == 0) goto <D.7861>; else goto <D.7862>;
    <D.7861>:
    GC_extend_size_map (lb);
    <D.7862>:
    D.7863 = GC_generic_malloc_inner (lb, k);
    return D.7863;
    <D.7857>:
    D.7864 = kind->ok_reclaim_list;
    if (D.7864 == 0B) goto <D.7865>; else goto <D.7866>;
    <D.7865>:
    D.7867 = GC_alloc_reclaim_list (kind);
    if (D.7867 == 0) goto out; else goto <D.7868>;
    <D.7868>:
    <D.7866>:
    op = GC_allocobj (lw, k);
    if (op == 0B) goto out; else goto <D.7869>;
    <D.7869>:
    <D.7854>:
    D.7870 = MEM[(char * *)op];
    *opp = D.7870;
    MEM[(char * *)op] = 0B;
  }
  goto <D.7871>;
  <D.7848>:
  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  GC_all_interior_pointers.7 = (long unsigned int) GC_all_interior_pointers.6;
  D.7872 = GC_all_interior_pointers.7 + lb;
  D.7873 = D.7872 + 3;
  lw = D.7873 >> 2;
  op = GC_alloc_large_and_clear (lw, k, 0);
  <D.7871>:
  D.7874 = GC_arrays._words_allocd;
  D.7875 = D.7874 + lw;
  GC_arrays._words_allocd = D.7875;
  out:
  D.7863 = op;
  return D.7863;
}


GC_generic_malloc_inner_ignore_off_page (size_t lb, int k)
{
  char * D.7879;
  int GC_all_interior_pointers.10;
  unsigned int GC_all_interior_pointers.11;
  unsigned int D.7882;
  unsigned int D.7883;
  long unsigned int D.7884;
  long unsigned int D.7885;
  register word lw;
  char * op;

  if (lb <= 4096) goto <D.7877>; else goto <D.7878>;
  <D.7877>:
  D.7879 = GC_generic_malloc_inner (lb, k);
  return D.7879;
  <D.7878>:
  GC_all_interior_pointers.10 = GC_all_interior_pointers;
  GC_all_interior_pointers.11 = (unsigned int) GC_all_interior_pointers.10;
  D.7882 = GC_all_interior_pointers.11 + lb;
  D.7883 = D.7882 + 3;
  lw = D.7883 >> 2;
  op = GC_alloc_large_and_clear (lw, k, 1);
  D.7884 = GC_arrays._words_allocd;
  D.7885 = D.7884 + lw;
  GC_arrays._words_allocd = D.7885;
  D.7879 = op;
  return D.7879;
}


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.7892;
  int D.7895;
  long unsigned int D.7899;
  long unsigned int D.7900;
  long unsigned int D.7901;
  long unsigned int D.7902;
  int D.7903;
  int GC_debugging_started.15;
  long unsigned int D.7911;
  word * D.7913;
  sizetype D.7914;
  sizetype D.7915;
  word * D.7916;
  sizetype D.7917;
  sizetype D.7918;
  word * D.7919;
  long unsigned int D.7920;
  long unsigned int D.7921;
  char * D.7930;
  void * (*<T10cf>) (size_t) GC_oom_fn.16;
  char * result;

  GC_have_errors.12 = GC_have_errors;
  if (GC_have_errors.12 != 0) goto <D.7888>; else goto <D.7889>;
  <D.7888>:
  GC_print_all_errors ();
  <D.7889>:
  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.7892 = 2048 - GC_all_interior_pointers.14;
  if (D.7892 >= lb) goto <D.7893>; else goto <D.7894>;
  <D.7893>:
  D.7895 = GC_test_and_set (&GC_allocate_lock);
  if (D.7895 != 0) goto <D.7896>; else goto <D.7897>;
  <D.7896>:
  GC_lock ();
  <D.7897>:
  result = GC_generic_malloc_inner (lb, k);
  GC_clear (&GC_allocate_lock);
  goto <D.7898>;
  <D.7894>:
  {
    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.7899 = GC_all_interior_pointers.14 + lb;
    D.7900 = D.7899 + 3;
    lw = D.7900 >> 2;
    D.7901 = lw << 2;
    D.7902 = D.7901 + 4095;
    n_blocks = D.7902 >> 12;
    init = GC_obj_kinds[k].ok_init;
    D.7903 = GC_test_and_set (&GC_allocate_lock);
    if (D.7903 != 0) goto <D.7904>; else goto <D.7905>;
    <D.7904>:
    GC_lock ();
    <D.7905>:
    result = GC_alloc_large (lw, k, 0);
    if (result != 0B) goto <D.7906>; else goto <D.7907>;
    <D.7906>:
    GC_debugging_started.15 = GC_debugging_started;
    if (GC_debugging_started.15 != 0) goto <D.7909>; else goto <D.7910>;
    <D.7909>:
    D.7911 = n_blocks * 4096;
    memset (result, 0, D.7911);
    goto <D.7912>;
    <D.7910>:
    MEM[(word *)result] = 0;
    D.7913 = result + 4;
    *D.7913 = 0;
    D.7914 = lw + 1073741823;
    D.7915 = D.7914 * 4;
    D.7916 = result + D.7915;
    *D.7916 = 0;
    D.7917 = lw + 1073741822;
    D.7918 = D.7917 * 4;
    D.7919 = result + D.7918;
    *D.7919 = 0;
    <D.7912>:
    <D.7907>:
    D.7920 = GC_arrays._words_allocd;
    D.7921 = D.7920 + lw;
    GC_arrays._words_allocd = D.7921;
    GC_clear (&GC_allocate_lock);
    if (init != 0) goto <D.7922>; else goto <D.7923>;
    <D.7922>:
    GC_debugging_started.15 = GC_debugging_started;
    if (GC_debugging_started.15 == 0) goto <D.7924>; else goto <D.7925>;
    <D.7924>:
    if (result != 0B) goto <D.7926>; else goto <D.7927>;
    <D.7926>:
    D.7911 = n_blocks * 4096;
    memset (result, 0, D.7911);
    <D.7927>:
    <D.7925>:
    <D.7923>:
  }
  <D.7898>:
  if (result == 0B) goto <D.7928>; else goto <D.7929>;
  <D.7928>:
  GC_oom_fn.16 = GC_oom_fn;
  D.7930 = GC_oom_fn.16 (lb);
  return D.7930;
  <D.7929>:
  D.7930 = result;
  return D.7930;
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.7933;
  unsigned int D.7934;

  D.7934 = __sync_lock_test_and_set_4 (addr, 1);
  D.7933 = (int) D.7934;
  return D.7933;
}


GC_clear (volatile unsigned int * addr)
{
  __sync_synchronize ();
  *addr = 0;
}


GC_malloc_atomic (size_t lb)
{
  int GC_all_interior_pointers.17;
  long unsigned int GC_all_interior_pointers.18;
  long unsigned int D.7938;
  _Bool D.7939;
  long int D.7940;
  long int D.7941;
  int D.7944;
  _Bool D.7947;
  long int D.7948;
  long int D.7949;
  void * D.7952;
  char * D.7953;
  char * D.7954;
  long unsigned int D.7955;
  long unsigned int D.7956;
  char * D.7957;
  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.7938 = 2048 - GC_all_interior_pointers.18;
  D.7939 = D.7938 >= lb;
  D.7940 = (long int) D.7939;
  D.7941 = __builtin_expect (D.7940, 1);
  if (D.7941 != 0) goto <D.7942>; else goto <D.7943>;
  <D.7942>:
  lw = GC_arrays._size_map[lb];
  opp = &GC_arrays._aobjfreelist[lw];
  D.7944 = GC_test_and_set (&GC_allocate_lock);
  if (D.7944 != 0) goto <D.7945>; else goto <D.7946>;
  <D.7945>:
  GC_lock ();
  <D.7946>:
  op = *opp;
  D.7947 = op == 0B;
  D.7948 = (long int) D.7947;
  D.7949 = __builtin_expect (D.7948, 0);
  if (D.7949 != 0) goto <D.7950>; else goto <D.7951>;
  <D.7950>:
  GC_clear (&GC_allocate_lock);
  D.7953 = GC_generic_malloc (lb, 0);
  D.7952 = GC_clear_stack (D.7953);
  return D.7952;
  <D.7951>:
  D.7954 = MEM[(char * *)op];
  *opp = D.7954;
  D.7955 = GC_arrays._words_allocd;
  D.7956 = D.7955 + lw;
  GC_arrays._words_allocd = D.7956;
  GC_clear (&GC_allocate_lock);
  D.7952 = op;
  return D.7952;
  <D.7943>:
  D.7957 = GC_generic_malloc (lb, 0);
  D.7952 = GC_clear_stack (D.7957);
  return D.7952;
}


GC_malloc (size_t lb)
{
  int GC_all_interior_pointers.19;
  long unsigned int GC_all_interior_pointers.20;
  long unsigned int D.7961;
  _Bool D.7962;
  long int D.7963;
  long int D.7964;
  int D.7967;
  _Bool D.7970;
  long int D.7971;
  long int D.7972;
  void * D.7975;
  char * D.7976;
  char * D.7977;
  long unsigned int D.7978;
  long unsigned int D.7979;
  char * D.7980;
  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.7961 = 2048 - GC_all_interior_pointers.20;
  D.7962 = D.7961 >= lb;
  D.7963 = (long int) D.7962;
  D.7964 = __builtin_expect (D.7963, 1);
  if (D.7964 != 0) goto <D.7965>; else goto <D.7966>;
  <D.7965>:
  lw = GC_arrays._size_map[lb];
  opp = &GC_arrays._objfreelist[lw];
  D.7967 = GC_test_and_set (&GC_allocate_lock);
  if (D.7967 != 0) goto <D.7968>; else goto <D.7969>;
  <D.7968>:
  GC_lock ();
  <D.7969>:
  op = *opp;
  D.7970 = op == 0B;
  D.7971 = (long int) D.7970;
  D.7972 = __builtin_expect (D.7971, 0);
  if (D.7972 != 0) goto <D.7973>; else goto <D.7974>;
  <D.7973>:
  GC_clear (&GC_allocate_lock);
  D.7976 = GC_generic_malloc (lb, 1);
  D.7975 = GC_clear_stack (D.7976);
  return D.7975;
  <D.7974>:
  D.7977 = MEM[(char * *)op];
  *opp = D.7977;
  MEM[(char * *)op] = 0B;
  D.7978 = GC_arrays._words_allocd;
  D.7979 = D.7978 + lw;
  GC_arrays._words_allocd = D.7979;
  GC_clear (&GC_allocate_lock);
  D.7975 = op;
  return D.7975;
  <D.7966>:
  D.7980 = GC_generic_malloc (lb, 1);
  D.7975 = GC_clear_stack (D.7980);
  return D.7975;
}


GC_free (void * p)
{
  long unsigned int p.21;
  long unsigned int D.7985;
  long unsigned int h.22;
  long unsigned int D.7987;
  struct bottom_index * D.7988;
  long unsigned int D.7989;
  long unsigned int D.7990;
  unsigned char D.7991;
  long unsigned int D.7992;
  long unsigned int sz.23;
  _Bool D.7994;
  long int D.7995;
  long int D.7996;
  int D.7999;
  long unsigned int D.8002;
  long unsigned int D.8003;
  int D.8004;
  long unsigned int GC_non_gc_bytes.24;
  long int D.8008;
  long unsigned int D.8009;
  long unsigned int GC_non_gc_bytes.25;
  int D.8011;
  void * D.8014;
  long int D.8015;
  long int D.8016;
  unsigned int D.8017;
  char * * D.8018;
  unsigned int sz.26;
  unsigned int D.8020;
  char * D.8021;
  int D.8023;
  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.7982>; else goto <D.7983>;
  <D.7982>:
  return;
  <D.7983>:
  p.21 = (long unsigned int) p;
  D.7985 = p.21 & 4294963200;
  h = (struct hblk *) D.7985;
  h.22 = (long unsigned int) h;
  D.7987 = h.22 >> 22;
  D.7988 = GC_arrays._top_index[D.7987];
  h.22 = (long unsigned int) h;
  D.7989 = h.22 >> 12;
  D.7990 = D.7989 & 1023;
  hhdr = D.7988->index[D.7990];
  D.7991 = hhdr->hb_obj_kind;
  knd = (int) D.7991;
  D.7992 = hhdr->hb_sz;
  sz = (signed_word) D.7992;
  ok = &GC_obj_kinds[knd];
  sz.23 = (long unsigned int) sz;
  D.7994 = sz.23 <= 512;
  D.7995 = (long int) D.7994;
  D.7996 = __builtin_expect (D.7995, 1);
  if (D.7996 != 0) goto <D.7997>; else goto <D.7998>;
  <D.7997>:
  D.7999 = GC_test_and_set (&GC_allocate_lock);
  if (D.7999 != 0) goto <D.8000>; else goto <D.8001>;
  <D.8000>:
  GC_lock ();
  <D.8001>:
  D.8002 = GC_arrays._mem_freed;
  sz.23 = (long unsigned int) sz;
  D.8003 = D.8002 + sz.23;
  GC_arrays._mem_freed = D.8003;
  D.8004 = knd & -2;
  if (D.8004 == 2) goto <D.8005>; else goto <D.8006>;
  <D.8005>:
  GC_non_gc_bytes.24 = GC_non_gc_bytes;
  D.8008 = sz << 2;
  D.8009 = (long unsigned int) D.8008;
  GC_non_gc_bytes.25 = GC_non_gc_bytes.24 - D.8009;
  GC_non_gc_bytes = GC_non_gc_bytes.25;
  <D.8006>:
  D.8011 = ok->ok_init;
  if (D.8011 != 0) goto <D.8012>; else goto <D.8013>;
  <D.8012>:
  D.8014 = p + 4;
  D.8015 = sz + -1;
  D.8016 = D.8015 << 2;
  D.8017 = (unsigned int) D.8016;
  memset (D.8014, 0, D.8017);
  <D.8013>:
  D.8018 = ok->ok_freelist;
  sz.26 = (unsigned int) sz;
  D.8020 = sz.26 * 4;
  flh = D.8018 + D.8020;
  D.8021 = *flh;
  MEM[(char * *)p] = D.8021;
  *flh = p;
  GC_clear (&GC_allocate_lock);
  goto <D.8022>;
  <D.7998>:
  D.8023 = GC_test_and_set (&GC_allocate_lock);
  if (D.8023 != 0) goto <D.8024>; else goto <D.8025>;
  <D.8024>:
  GC_lock ();
  <D.8025>:
  D.8002 = GC_arrays._mem_freed;
  sz.23 = (long unsigned int) sz;
  D.8003 = D.8002 + sz.23;
  GC_arrays._mem_freed = D.8003;
  D.8004 = knd & -2;
  if (D.8004 == 2) goto <D.8026>; else goto <D.8027>;
  <D.8026>:
  GC_non_gc_bytes.24 = GC_non_gc_bytes;
  D.8008 = sz << 2;
  D.8009 = (long unsigned int) D.8008;
  GC_non_gc_bytes.25 = GC_non_gc_bytes.24 - D.8009;
  GC_non_gc_bytes = GC_non_gc_bytes.25;
  <D.8027>:
  GC_freehblk (h);
  GC_clear (&GC_allocate_lock);
  <D.8022>:
}


GC_free_inner (void * p)
{
  long unsigned int p.27;
  long unsigned int D.8030;
  long unsigned int h.28;
  long unsigned int D.8032;
  struct bottom_index * D.8033;
  long unsigned int D.8034;
  long unsigned int D.8035;
  unsigned char D.8036;
  long unsigned int D.8037;
  long unsigned int sz.29;
  long unsigned int D.8041;
  long unsigned int D.8042;
  int D.8043;
  long unsigned int GC_non_gc_bytes.30;
  long int D.8047;
  long unsigned int D.8048;
  long unsigned int GC_non_gc_bytes.31;
  int D.8050;
  void * D.8053;
  long int D.8054;
  long int D.8055;
  unsigned int D.8056;
  char * * D.8057;
  unsigned int sz.32;
  unsigned int D.8059;
  char * D.8060;
  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.8030 = p.27 & 4294963200;
  h = (struct hblk *) D.8030;
  h.28 = (long unsigned int) h;
  D.8032 = h.28 >> 22;
  D.8033 = GC_arrays._top_index[D.8032];
  h.28 = (long unsigned int) h;
  D.8034 = h.28 >> 12;
  D.8035 = D.8034 & 1023;
  hhdr = D.8033->index[D.8035];
  D.8036 = hhdr->hb_obj_kind;
  knd = (int) D.8036;
  D.8037 = hhdr->hb_sz;
  sz = (signed_word) D.8037;
  ok = &GC_obj_kinds[knd];
  sz.29 = (long unsigned int) sz;
  if (sz.29 <= 512) goto <D.8039>; else goto <D.8040>;
  <D.8039>:
  D.8041 = GC_arrays._mem_freed;
  sz.29 = (long unsigned int) sz;
  D.8042 = D.8041 + sz.29;
  GC_arrays._mem_freed = D.8042;
  D.8043 = knd & -2;
  if (D.8043 == 2) goto <D.8044>; else goto <D.8045>;
  <D.8044>:
  GC_non_gc_bytes.30 = GC_non_gc_bytes;
  D.8047 = sz << 2;
  D.8048 = (long unsigned int) D.8047;
  GC_non_gc_bytes.31 = GC_non_gc_bytes.30 - D.8048;
  GC_non_gc_bytes = GC_non_gc_bytes.31;
  <D.8045>:
  D.8050 = ok->ok_init;
  if (D.8050 != 0) goto <D.8051>; else goto <D.8052>;
  <D.8051>:
  D.8053 = p + 4;
  D.8054 = sz + -1;
  D.8055 = D.8054 << 2;
  D.8056 = (unsigned int) D.8055;
  memset (D.8053, 0, D.8056);
  <D.8052>:
  D.8057 = ok->ok_freelist;
  sz.32 = (unsigned int) sz;
  D.8059 = sz.32 * 4;
  flh = D.8057 + D.8059;
  D.8060 = *flh;
  MEM[(char * *)p] = D.8060;
  *flh = p;
  goto <D.8061>;
  <D.8040>:
  D.8041 = GC_arrays._mem_freed;
  sz.29 = (long unsigned int) sz;
  D.8042 = D.8041 + sz.29;
  GC_arrays._mem_freed = D.8042;
  D.8043 = knd & -2;
  if (D.8043 == 2) goto <D.8062>; else goto <D.8063>;
  <D.8062>:
  GC_non_gc_bytes.30 = GC_non_gc_bytes;
  D.8047 = sz << 2;
  D.8048 = (long unsigned int) D.8047;
  GC_non_gc_bytes.31 = GC_non_gc_bytes.30 - D.8048;
  GC_non_gc_bytes = GC_non_gc_bytes.31;
  <D.8063>:
  GC_freehblk (h);
  <D.8061>:
}