GC_generic_or_special_malloc (word lb, int knd)
{
  void * D.7813;

  switch (knd) <default: <D.7713>, case 0: <D.7709>, case 1: <D.7710>, case 2: <D.7711>, case 3: <D.7712>>
  <D.7709>:
  D.7813 = GC_malloc_atomic (lb);
  return D.7813;
  <D.7710>:
  D.7813 = GC_malloc (lb);
  return D.7813;
  <D.7711>:
  D.7813 = GC_malloc_uncollectable (lb);
  return D.7813;
  <D.7712>:
  D.7813 = GC_malloc_atomic_uncollectable (lb);
  return D.7813;
  <D.7713>:
  D.7813 = GC_generic_malloc (lb, knd);
  return D.7813;
}


GC_realloc (void * p, size_t lb)
{
  void * D.7817;
  long unsigned int p.0;
  long unsigned int D.7819;
  long unsigned int h.1;
  long unsigned int D.7821;
  struct bottom_index * D.7822;
  long unsigned int D.7823;
  long unsigned int D.7824;
  unsigned char D.7825;
  long unsigned int D.7828;
  long unsigned int D.7829;
  int D.7830;
  int D.7833;
  long unsigned int D.7836;
  long unsigned int GC_non_gc_bytes.2;
  long unsigned int GC_non_gc_bytes.3;
  int GC_all_interior_pointers.4;
  unsigned int GC_all_interior_pointers.5;
  unsigned int D.7841;
  long unsigned int D.7844;
  void * D.7849;
  long unsigned int D.7850;
  register struct hblk * h;
  register struct hdr * hhdr;
  register word sz;
  register word orig_sz;
  int obj_kind;

  if (p == 0B) goto <D.7815>; else goto <D.7816>;
  <D.7815>:
  D.7817 = GC_malloc (lb);
  return D.7817;
  <D.7816>:
  p.0 = (long unsigned int) p;
  D.7819 = p.0 & 4294963200;
  h = (struct hblk *) D.7819;
  h.1 = (long unsigned int) h;
  D.7821 = h.1 >> 22;
  D.7822 = GC_arrays._top_index[D.7821];
  h.1 = (long unsigned int) h;
  D.7823 = h.1 >> 12;
  D.7824 = D.7823 & 1023;
  hhdr = D.7822->index[D.7824];
  sz = hhdr->hb_sz;
  D.7825 = hhdr->hb_obj_kind;
  obj_kind = (int) D.7825;
  sz = sz << 2;
  orig_sz = sz;
  if (sz > 2048) goto <D.7826>; else goto <D.7827>;
  <D.7826>:
  {
    register word descr;

    D.7828 = sz + 4095;
    sz = D.7828 & 4294963200;
    D.7829 = sz >> 2;
    hhdr->hb_sz = D.7829;
    descr = GC_obj_kinds[obj_kind].ok_descriptor;
    D.7830 = GC_obj_kinds[obj_kind].ok_relocate_descr;
    if (D.7830 != 0) goto <D.7831>; else goto <D.7832>;
    <D.7831>:
    descr = descr + sz;
    <D.7832>:
    hhdr->hb_descr = descr;
    D.7833 = obj_kind & -2;
    if (D.7833 == 2) goto <D.7834>; else goto <D.7835>;
    <D.7834>:
    D.7836 = sz - orig_sz;
    GC_non_gc_bytes.2 = GC_non_gc_bytes;
    GC_non_gc_bytes.3 = D.7836 + GC_non_gc_bytes.2;
    GC_non_gc_bytes = GC_non_gc_bytes.3;
    <D.7835>:
  }
  <D.7827>:
  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  GC_all_interior_pointers.5 = (unsigned int) GC_all_interior_pointers.4;
  D.7841 = lb + GC_all_interior_pointers.5;
  if (D.7841 <= sz) goto <D.7842>; else goto <D.7843>;
  <D.7842>:
  D.7844 = sz >> 1;
  if (D.7844 <= lb) goto <D.7845>; else goto <D.7846>;
  <D.7845>:
  if (orig_sz > lb) goto <D.7847>; else goto <D.7848>;
  <D.7847>:
  D.7849 = p + lb;
  D.7850 = orig_sz - lb;
  memset (D.7849, 0, D.7850);
  <D.7848>:
  D.7817 = p;
  return D.7817;
  <D.7846>:
  {
    void * result;

    result = GC_generic_or_special_malloc (lb, obj_kind);
    if (result == 0B) goto <D.7851>; else goto <D.7852>;
    <D.7851>:
    D.7817 = 0B;
    return D.7817;
    <D.7852>:
    memcpy (result, p, lb);
    GC_free (p);
    D.7817 = result;
    return D.7817;
  }
  <D.7843>:
  {
    void * result;

    result = GC_generic_or_special_malloc (lb, obj_kind);
    if (result == 0B) goto <D.7853>; else goto <D.7854>;
    <D.7853>:
    D.7817 = 0B;
    return D.7817;
    <D.7854>:
    memcpy (result, p, sz);
    GC_free (p);
    D.7817 = result;
    return D.7817;
  }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.7858;
  int D.7863;
  void * D.7865;
  unsigned int D.7866;

  D.7858 = __builtin_constant_p (__len);
  if (D.7858 != 0) goto <D.7859>; else goto <D.7860>;
  <D.7859>:
  if (__len == 0) goto <D.7861>; else goto <D.7862>;
  <D.7861>:
  D.7863 = __builtin_constant_p (__ch);
  if (D.7863 == 0) goto <D.7856>; else goto <D.7864>;
  <D.7864>:
  if (__ch != 0) goto <D.7856>; else goto <D.7857>;
  <D.7856>:
  __warn_memset_zero_len ();
  D.7865 = __dest;
  return D.7865;
  <D.7857>:
  <D.7862>:
  <D.7860>:
  D.7866 = __builtin_object_size (__dest, 0);
  D.7865 = __builtin___memset_chk (__dest, __ch, __len, D.7866);
  return D.7865;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.7868;
  unsigned int D.7869;

  D.7869 = __builtin_object_size (__dest, 0);
  D.7868 = __builtin___memcpy_chk (__dest, __src, __len, D.7869);
  return D.7868;
}


GC_generic_malloc_ignore_off_page (size_t lb, int k)
{
  int GC_all_interior_pointers.6;
  long unsigned int GC_all_interior_pointers.7;
  long unsigned int D.7873;
  char * D.7876;
  unsigned int GC_all_interior_pointers.8;
  unsigned int D.7878;
  unsigned int D.7879;
  long unsigned int D.7880;
  long unsigned int D.7881;
  int GC_have_errors.9;
  int D.7885;
  int GC_debugging_started.10;
  long unsigned int D.7893;
  word * D.7895;
  sizetype D.7896;
  sizetype D.7897;
  word * D.7898;
  sizetype D.7899;
  sizetype D.7900;
  word * D.7901;
  long unsigned int D.7902;
  long unsigned int D.7903;
  void * (*<T10cf>) (size_t) GC_oom_fn.11;
  register char * result;
  word lw;
  word n_blocks;
  GC_bool init;

  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  GC_all_interior_pointers.7 = (long unsigned int) GC_all_interior_pointers.6;
  D.7873 = 2048 - GC_all_interior_pointers.7;
  if (D.7873 >= lb) goto <D.7874>; else goto <D.7875>;
  <D.7874>:
  D.7876 = GC_generic_malloc (lb, k);
  return D.7876;
  <D.7875>:
  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  GC_all_interior_pointers.8 = (unsigned int) GC_all_interior_pointers.6;
  D.7878 = GC_all_interior_pointers.8 + lb;
  D.7879 = D.7878 + 3;
  lw = D.7879 >> 2;
  D.7880 = lw << 2;
  D.7881 = D.7880 + 4095;
  n_blocks = D.7881 >> 12;
  init = GC_obj_kinds[k].ok_init;
  GC_have_errors.9 = GC_have_errors;
  if (GC_have_errors.9 != 0) goto <D.7883>; else goto <D.7884>;
  <D.7883>:
  GC_print_all_errors ();
  <D.7884>:
  GC_notify_or_invoke_finalizers ();
  D.7885 = GC_test_and_set (&GC_allocate_lock);
  if (D.7885 != 0) goto <D.7886>; else goto <D.7887>;
  <D.7886>:
  GC_lock ();
  <D.7887>:
  result = GC_alloc_large (lw, k, 1);
  if (result != 0B) goto <D.7888>; else goto <D.7889>;
  <D.7888>:
  GC_debugging_started.10 = GC_debugging_started;
  if (GC_debugging_started.10 != 0) goto <D.7891>; else goto <D.7892>;
  <D.7891>:
  D.7893 = n_blocks * 4096;
  memset (result, 0, D.7893);
  goto <D.7894>;
  <D.7892>:
  MEM[(word *)result] = 0;
  D.7895 = result + 4;
  *D.7895 = 0;
  D.7896 = lw + 1073741823;
  D.7897 = D.7896 * 4;
  D.7898 = result + D.7897;
  *D.7898 = 0;
  D.7899 = lw + 1073741822;
  D.7900 = D.7899 * 4;
  D.7901 = result + D.7900;
  *D.7901 = 0;
  <D.7894>:
  <D.7889>:
  D.7902 = GC_arrays._words_allocd;
  D.7903 = D.7902 + lw;
  GC_arrays._words_allocd = D.7903;
  GC_clear (&GC_allocate_lock);
  if (result == 0B) goto <D.7904>; else goto <D.7905>;
  <D.7904>:
  GC_oom_fn.11 = GC_oom_fn;
  D.7876 = GC_oom_fn.11 (lb);
  return D.7876;
  <D.7905>:
  if (init != 0) goto <D.7907>; else goto <D.7908>;
  <D.7907>:
  GC_debugging_started.10 = GC_debugging_started;
  if (GC_debugging_started.10 == 0) goto <D.7909>; else goto <D.7910>;
  <D.7909>:
  D.7893 = n_blocks * 4096;
  memset (result, 0, D.7893);
  <D.7910>:
  <D.7908>:
  D.7876 = result;
  return D.7876;
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.7912;
  unsigned int D.7913;

  D.7913 = __sync_lock_test_and_set_4 (addr, 1);
  D.7912 = (int) D.7913;
  return D.7912;
}


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


GC_malloc_ignore_off_page (size_t lb)
{
  void * D.7915;

  D.7915 = GC_generic_malloc_ignore_off_page (lb, 1);
  return D.7915;
}


GC_malloc_atomic_ignore_off_page (size_t lb)
{
  void * D.7917;

  D.7917 = GC_generic_malloc_ignore_off_page (lb, 0);
  return D.7917;
}


GC_incr_words_allocd (size_t n)
{
  long unsigned int D.7919;
  long unsigned int D.7920;

  D.7919 = GC_arrays._words_allocd;
  D.7920 = D.7919 + n;
  GC_arrays._words_allocd = D.7920;
}


GC_incr_mem_freed (size_t n)
{
  long unsigned int D.7921;
  long unsigned int D.7922;

  D.7921 = GC_arrays._mem_freed;
  D.7922 = D.7921 + n;
  GC_arrays._mem_freed = D.7922;
}


GC_generic_malloc_words_small_inner (word lw, int k)
{
  unsigned int k.12;
  unsigned int D.7924;
  char * * D.7925;
  long unsigned int D.7926;
  int GC_is_initialized.13;
  struct hblk * * D.7934;
  int D.7936;
  char * D.7937;
  char * D.7940;
  void * (*<T10cf>) (size_t) GC_oom_fn.14;
  long unsigned int D.7942;
  char * D.7943;
  long unsigned int D.7944;
  long unsigned int D.7945;
  register char * op;
  register char * * opp;
  register struct obj_kind * kind;

  k.12 = (unsigned int) k;
  D.7924 = k.12 * 20;
  kind = &GC_obj_kinds + D.7924;
  D.7925 = kind->ok_freelist;
  D.7926 = lw * 4;
  opp = D.7925 + D.7926;
  op = *opp;
  if (op == 0B) goto <D.7927>; else goto <D.7928>;
  <D.7927>:
  GC_is_initialized.13 = GC_is_initialized;
  if (GC_is_initialized.13 == 0) goto <D.7930>; else goto <D.7931>;
  <D.7930>:
  GC_init_inner ();
  <D.7931>:
  D.7934 = kind->ok_reclaim_list;
  if (D.7934 != 0B) goto <D.7932>; else goto <D.7935>;
  <D.7935>:
  D.7936 = GC_alloc_reclaim_list (kind);
  if (D.7936 != 0) goto <D.7932>; else goto <D.7933>;
  <D.7932>:
  D.7937 = GC_allocobj (lw, k);
  op = GC_clear_stack (D.7937);
  <D.7933>:
  if (op == 0B) goto <D.7938>; else goto <D.7939>;
  <D.7938>:
  GC_clear (&GC_allocate_lock);
  GC_oom_fn.14 = GC_oom_fn;
  D.7942 = lw << 2;
  D.7940 = GC_oom_fn.14 (D.7942);
  return D.7940;
  <D.7939>:
  <D.7928>:
  D.7943 = MEM[(char * *)op];
  *opp = D.7943;
  MEM[(char * *)op] = 0B;
  D.7944 = GC_arrays._words_allocd;
  D.7945 = D.7944 + lw;
  GC_arrays._words_allocd = D.7945;
  D.7940 = op;
  return D.7940;
}


GC_generic_malloc_words_small (size_t lw, int k)
{
  int GC_have_errors.15;
  int D.7950;
  char * D.7953;
  register char * op;

  GC_have_errors.15 = GC_have_errors;
  if (GC_have_errors.15 != 0) goto <D.7948>; else goto <D.7949>;
  <D.7948>:
  GC_print_all_errors ();
  <D.7949>:
  GC_notify_or_invoke_finalizers ();
  D.7950 = GC_test_and_set (&GC_allocate_lock);
  if (D.7950 != 0) goto <D.7951>; else goto <D.7952>;
  <D.7951>:
  GC_lock ();
  <D.7952>:
  op = GC_generic_malloc_words_small_inner (lw, k);
  GC_clear (&GC_allocate_lock);
  D.7953 = op;
  return D.7953;
}


GC_generic_malloc_many (word lb, int k, char * * result)
{
  int GC_all_interior_pointers.16;
  long unsigned int GC_all_interior_pointers.17;
  long unsigned int D.7957;
  long unsigned int D.7962;
  long unsigned int D.7963;
  long unsigned int D.7964;
  int GC_have_errors.18;
  int D.7968;
  int GC_is_initialized.19;
  int GC_incremental.20;
  int GC_dont_gc.21;
  long unsigned int D.7980;
  long unsigned int hbp.22;
  long unsigned int D.7982;
  struct bottom_index * D.7983;
  long unsigned int D.7984;
  long unsigned int D.7985;
  struct hblk * D.7986;
  long unsigned int GC_gc_no.23;
  short unsigned int D.7988;
  int D.7989;
  long unsigned int D.7992;
  long unsigned int D.7993;
  char * * D.7994;
  char * D.7999;
  int D.8002;
  long unsigned int h.24;
  long unsigned int D.8006;
  struct bottom_index * D.8007;
  long unsigned int D.8008;
  long unsigned int D.8009;
  struct hdr * D.8010;
  long unsigned int D.8011;
  long unsigned int D.8012;
  long unsigned int D.8013;
  char * op;
  char * p;
  char * * opp;
  word lw;
  word my_words_allocd;
  struct obj_kind * ok;
  void out = <<< error >>>;

  my_words_allocd = 0;
  ok = &GC_obj_kinds[k];
  GC_all_interior_pointers.16 = GC_all_interior_pointers;
  GC_all_interior_pointers.17 = (long unsigned int) GC_all_interior_pointers.16;
  D.7957 = 2048 - GC_all_interior_pointers.17;
  if (D.7957 < lb) goto <D.7958>; else goto <D.7959>;
  <D.7958>:
  op = GC_generic_malloc (lb, k);
  if (op != 0B) goto <D.7960>; else goto <D.7961>;
  <D.7960>:
  MEM[(char * *)op] = 0B;
  <D.7961>:
  *result = op;
  return;
  <D.7959>:
  GC_all_interior_pointers.16 = GC_all_interior_pointers;
  GC_all_interior_pointers.17 = (long unsigned int) GC_all_interior_pointers.16;
  D.7962 = lb + GC_all_interior_pointers.17;
  D.7963 = D.7962 + 7;
  D.7964 = D.7963 >> 2;
  lw = D.7964 & 4294967294;
  GC_have_errors.18 = GC_have_errors;
  if (GC_have_errors.18 != 0) goto <D.7966>; else goto <D.7967>;
  <D.7966>:
  GC_print_all_errors ();
  <D.7967>:
  GC_notify_or_invoke_finalizers ();
  D.7968 = GC_test_and_set (&GC_allocate_lock);
  if (D.7968 != 0) goto <D.7969>; else goto <D.7970>;
  <D.7969>:
  GC_lock ();
  <D.7970>:
  GC_is_initialized.19 = GC_is_initialized;
  if (GC_is_initialized.19 == 0) goto <D.7972>; else goto <D.7973>;
  <D.7972>:
  GC_init_inner ();
  <D.7973>:
  GC_incremental.20 = GC_incremental;
  if (GC_incremental.20 != 0) goto <D.7975>; else goto <D.7976>;
  <D.7975>:
  GC_dont_gc.21 = GC_dont_gc;
  if (GC_dont_gc.21 == 0) goto <D.7978>; else goto <D.7979>;
  <D.7978>:
  GC_collecting = 1;
  GC_collect_a_little_inner (1);
  GC_collecting = 0;
  <D.7979>:
  <D.7976>:
  {
    struct hblk * * rlh;
    struct hblk * hbp;
    struct hdr * hhdr;

    rlh = ok->ok_reclaim_list;
    D.7980 = lw * 4;
    rlh = rlh + D.7980;
    goto <D.7779>;
    <D.7778>:
    hbp.22 = (long unsigned int) hbp;
    D.7982 = hbp.22 >> 22;
    D.7983 = GC_arrays._top_index[D.7982];
    hbp.22 = (long unsigned int) hbp;
    D.7984 = hbp.22 >> 12;
    D.7985 = D.7984 & 1023;
    hhdr = D.7983->index[D.7985];
    D.7986 = hhdr->hb_next;
    *rlh = D.7986;
    GC_gc_no.23 = GC_gc_no;
    D.7988 = (short unsigned int) GC_gc_no.23;
    hhdr->hb_last_reclaimed = D.7988;
    D.7989 = ok->ok_init;
    op = GC_reclaim_generic (hbp, hhdr, lw, D.7989, 0);
    if (op != 0B) goto <D.7990>; else goto <D.7991>;
    <D.7990>:
    p = op;
    goto <D.7775>;
    <D.7774>:
    my_words_allocd = my_words_allocd + lw;
    p = MEM[(char * *)p];
    <D.7775>:
    if (p != 0B) goto <D.7774>; else goto <D.7776>;
    <D.7776>:
    D.7992 = GC_arrays._words_allocd;
    D.7993 = D.7992 + my_words_allocd;
    GC_arrays._words_allocd = D.7993;
    goto out;
    <D.7991>:
    <D.7779>:
    hbp = *rlh;
    if (hbp != 0B) goto <D.7778>; else goto <D.7780>;
    <D.7780>:
  }
  D.7994 = GC_obj_kinds[k].ok_freelist;
  D.7980 = lw * 4;
  opp = D.7994 + D.7980;
  op = *opp;
  if (op != 0B) goto <D.7995>; else goto <D.7996>;
  <D.7995>:
  *opp = 0B;
  my_words_allocd = 0;
  p = op;
  goto <D.7783>;
  <D.7782>:
  my_words_allocd = my_words_allocd + lw;
  if (my_words_allocd > 1023) goto <D.7997>; else goto <D.7998>;
  <D.7997>:
  D.7999 = MEM[(char * *)p];
  *opp = D.7999;
  MEM[(char * *)p] = 0B;
  goto <D.7781>;
  <D.7998>:
  p = MEM[(char * *)p];
  <D.7783>:
  if (p != 0B) goto <D.7782>; else goto <D.7781>;
  <D.7781>:
  D.7992 = GC_arrays._words_allocd;
  D.7993 = D.7992 + my_words_allocd;
  GC_arrays._words_allocd = D.7993;
  goto out;
  <D.7996>:
  {
    struct hblk * h;

    h = GC_allochblk (lw, k, 0);
    if (h != 0B) goto <D.8000>; else goto <D.8001>;
    <D.8000>:
    D.8002 = k & -2;
    if (D.8002 == 2) goto <D.8003>; else goto <D.8004>;
    <D.8003>:
    h.24 = (long unsigned int) h;
    D.8006 = h.24 >> 22;
    D.8007 = GC_arrays._top_index[D.8006];
    h.24 = (long unsigned int) h;
    D.8008 = h.24 >> 12;
    D.8009 = D.8008 & 1023;
    D.8010 = D.8007->index[D.8009];
    GC_set_hdr_marks (D.8010);
    <D.8004>:
    D.7992 = GC_arrays._words_allocd;
    D.8011 = 1024 % lw;
    D.8012 = D.7992 - D.8011;
    D.8013 = D.8012 + 1024;
    GC_arrays._words_allocd = D.8013;
    D.7989 = ok->ok_init;
    op = GC_build_fl (h, lw, D.7989, 0B);
    goto out;
    <D.8001>:
  }
  op = GC_generic_malloc_inner (lb, k);
  if (op != 0B) goto <D.8014>; else goto <D.8015>;
  <D.8014>:
  MEM[(char * *)op] = 0B;
  <D.8015>:
  out:
  *result = op;
  GC_clear (&GC_allocate_lock);
  GC_clear_stack (0);
}


GC_malloc_many (size_t lb)
{
  void * D.8017;
  char * result;

  try
    {
      GC_generic_malloc_many (lb, 1, &result);
      D.8017 = result;
      return D.8017;
    }
  finally
    {
      result = {CLOBBER};
    }
}


GC_malloc_uncollectable (size_t lb)
{
  int GC_all_interior_pointers.25;
  long unsigned int GC_all_interior_pointers.26;
  long unsigned int D.8022;
  int D.8029;
  char * D.8034;
  long unsigned int D.8035;
  long unsigned int D.8036;
  long unsigned int D.8037;
  long unsigned int GC_non_gc_bytes.27;
  long unsigned int GC_non_gc_bytes.28;
  void * D.8040;
  long unsigned int op.29;
  long unsigned int D.8045;
  long unsigned int h.30;
  long unsigned int D.8047;
  struct bottom_index * D.8048;
  long unsigned int D.8049;
  long unsigned int D.8050;
  struct hdr * D.8051;
  int D.8052;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.25 = GC_all_interior_pointers;
  GC_all_interior_pointers.26 = (long unsigned int) GC_all_interior_pointers.25;
  D.8022 = 2048 - GC_all_interior_pointers.26;
  if (D.8022 >= lb) goto <D.8023>; else goto <D.8024>;
  <D.8023>:
  GC_all_interior_pointers.25 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.25 != 0) goto <D.8025>; else goto <D.8026>;
  <D.8025>:
  if (lb != 0) goto <D.8027>; else goto <D.8028>;
  <D.8027>:
  lb = lb + 4294967295;
  <D.8028>:
  <D.8026>:
  lw = GC_arrays._size_map[lb];
  opp = &GC_arrays._uobjfreelist[lw];
  D.8029 = GC_test_and_set (&GC_allocate_lock);
  if (D.8029 != 0) goto <D.8030>; else goto <D.8031>;
  <D.8030>:
  GC_lock ();
  <D.8031>:
  op = *opp;
  if (op != 0B) goto <D.8032>; else goto <D.8033>;
  <D.8032>:
  D.8034 = MEM[(char * *)op];
  *opp = D.8034;
  MEM[(char * *)op] = 0B;
  D.8035 = GC_arrays._words_allocd;
  D.8036 = D.8035 + lw;
  GC_arrays._words_allocd = D.8036;
  D.8037 = lw << 2;
  GC_non_gc_bytes.27 = GC_non_gc_bytes;
  GC_non_gc_bytes.28 = D.8037 + GC_non_gc_bytes.27;
  GC_non_gc_bytes = GC_non_gc_bytes.28;
  GC_clear (&GC_allocate_lock);
  D.8040 = op;
  return D.8040;
  <D.8033>:
  GC_clear (&GC_allocate_lock);
  op = GC_generic_malloc (lb, 2);
  goto <D.8041>;
  <D.8024>:
  op = GC_generic_malloc (lb, 2);
  <D.8041>:
  if (op == 0B) goto <D.8042>; else goto <D.8043>;
  <D.8042>:
  D.8040 = 0B;
  return D.8040;
  <D.8043>:
  {
    register struct hblk * h;

    op.29 = (long unsigned int) op;
    D.8045 = op.29 & 4294963200;
    h = (struct hblk *) D.8045;
    h.30 = (long unsigned int) h;
    D.8047 = h.30 >> 22;
    D.8048 = GC_arrays._top_index[D.8047];
    h.30 = (long unsigned int) h;
    D.8049 = h.30 >> 12;
    D.8050 = D.8049 & 1023;
    D.8051 = D.8048->index[D.8050];
    lw = D.8051->hb_sz;
    D.8052 = GC_test_and_set (&GC_allocate_lock);
    if (D.8052 != 0) goto <D.8053>; else goto <D.8054>;
    <D.8053>:
    GC_lock ();
    <D.8054>:
    GC_set_mark_bit (op);
    D.8037 = lw << 2;
    GC_non_gc_bytes.27 = GC_non_gc_bytes;
    GC_non_gc_bytes.28 = D.8037 + GC_non_gc_bytes.27;
    GC_non_gc_bytes = GC_non_gc_bytes.28;
    GC_clear (&GC_allocate_lock);
    D.8040 = op;
    return D.8040;
  }
}


GC_memalign (size_t align, size_t lb)
{
  _Bool D.8056;
  _Bool D.8057;
  _Bool D.8058;
  void * D.8061;
  _Bool D.8064;
  _Bool D.8065;
  _Bool D.8066;
  void * (*<T10cf>) (size_t) GC_oom_fn.31;
  long unsigned int D.8072;
  unsigned int D.8073;
  long unsigned int result.32;
  int GC_all_interior_pointers.33;
  size_t new_lb;
  size_t offset;
  char * result;

  D.8056 = align <= 8;
  D.8057 = lb > align;
  D.8058 = D.8056 & D.8057;
  if (D.8058 != 0) goto <D.8059>; else goto <D.8060>;
  <D.8059>:
  D.8061 = GC_malloc (lb);
  return D.8061;
  <D.8060>:
  if (align <= 4) goto <D.8062>; else goto <D.8063>;
  <D.8062>:
  D.8061 = GC_malloc (lb);
  return D.8061;
  <D.8063>:
  D.8064 = align > 2047;
  D.8065 = lb > 2047;
  D.8066 = D.8064 | D.8065;
  if (D.8066 != 0) goto <D.8067>; else goto <D.8068>;
  <D.8067>:
  if (align > 4096) goto <D.8069>; else goto <D.8070>;
  <D.8069>:
  GC_oom_fn.31 = GC_oom_fn;
  D.8061 = GC_oom_fn.31 (2147482623);
  return D.8061;
  <D.8070>:
  D.8072 = MAX_EXPR <lb, 4096>;
  D.8061 = GC_malloc (D.8072);
  return D.8061;
  <D.8068>:
  D.8073 = lb + align;
  new_lb = D.8073 + 4294967295;
  result = GC_malloc (new_lb);
  result.32 = (long unsigned int) result;
  offset = result.32 % align;
  if (offset != 0) goto <D.8075>; else goto <D.8076>;
  <D.8075>:
  offset = align - offset;
  GC_all_interior_pointers.33 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.33 == 0) goto <D.8078>; else goto <D.8079>;
  <D.8078>:
  if (offset > 2048) goto <D.8080>; else goto <D.8081>;
  <D.8080>:
  D.8061 = GC_malloc (4096);
  return D.8061;
  <D.8081>:
  GC_register_displacement (offset);
  <D.8079>:
  <D.8076>:
  result = result + offset;
  D.8061 = result;
  return D.8061;
}


GC_malloc_atomic_uncollectable (size_t lb)
{
  int GC_all_interior_pointers.34;
  long unsigned int GC_all_interior_pointers.35;
  long unsigned int D.8085;
  int D.8092;
  char * D.8097;
  long unsigned int D.8098;
  long unsigned int D.8099;
  long unsigned int D.8100;
  long unsigned int GC_non_gc_bytes.36;
  long unsigned int GC_non_gc_bytes.37;
  void * D.8103;
  long unsigned int op.38;
  long unsigned int D.8108;
  long unsigned int h.39;
  long unsigned int D.8110;
  struct bottom_index * D.8111;
  long unsigned int D.8112;
  long unsigned int D.8113;
  struct hdr * D.8114;
  int D.8115;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.34 = GC_all_interior_pointers;
  GC_all_interior_pointers.35 = (long unsigned int) GC_all_interior_pointers.34;
  D.8085 = 2048 - GC_all_interior_pointers.35;
  if (D.8085 >= lb) goto <D.8086>; else goto <D.8087>;
  <D.8086>:
  GC_all_interior_pointers.34 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.34 != 0) goto <D.8088>; else goto <D.8089>;
  <D.8088>:
  if (lb != 0) goto <D.8090>; else goto <D.8091>;
  <D.8090>:
  lb = lb + 4294967295;
  <D.8091>:
  <D.8089>:
  lw = GC_arrays._size_map[lb];
  opp = &GC_arrays._auobjfreelist[lw];
  D.8092 = GC_test_and_set (&GC_allocate_lock);
  if (D.8092 != 0) goto <D.8093>; else goto <D.8094>;
  <D.8093>:
  GC_lock ();
  <D.8094>:
  op = *opp;
  if (op != 0B) goto <D.8095>; else goto <D.8096>;
  <D.8095>:
  D.8097 = MEM[(char * *)op];
  *opp = D.8097;
  MEM[(char * *)op] = 0B;
  D.8098 = GC_arrays._words_allocd;
  D.8099 = D.8098 + lw;
  GC_arrays._words_allocd = D.8099;
  D.8100 = lw << 2;
  GC_non_gc_bytes.36 = GC_non_gc_bytes;
  GC_non_gc_bytes.37 = D.8100 + GC_non_gc_bytes.36;
  GC_non_gc_bytes = GC_non_gc_bytes.37;
  GC_clear (&GC_allocate_lock);
  D.8103 = op;
  return D.8103;
  <D.8096>:
  GC_clear (&GC_allocate_lock);
  op = GC_generic_malloc (lb, 3);
  goto <D.8104>;
  <D.8087>:
  op = GC_generic_malloc (lb, 3);
  <D.8104>:
  if (op == 0B) goto <D.8105>; else goto <D.8106>;
  <D.8105>:
  D.8103 = 0B;
  return D.8103;
  <D.8106>:
  {
    register struct hblk * h;

    op.38 = (long unsigned int) op;
    D.8108 = op.38 & 4294963200;
    h = (struct hblk *) D.8108;
    h.39 = (long unsigned int) h;
    D.8110 = h.39 >> 22;
    D.8111 = GC_arrays._top_index[D.8110];
    h.39 = (long unsigned int) h;
    D.8112 = h.39 >> 12;
    D.8113 = D.8112 & 1023;
    D.8114 = D.8111->index[D.8113];
    lw = D.8114->hb_sz;
    D.8115 = GC_test_and_set (&GC_allocate_lock);
    if (D.8115 != 0) goto <D.8116>; else goto <D.8117>;
    <D.8116>:
    GC_lock ();
    <D.8117>:
    GC_set_mark_bit (op);
    D.8100 = lw << 2;
    GC_non_gc_bytes.36 = GC_non_gc_bytes;
    GC_non_gc_bytes.37 = D.8100 + GC_non_gc_bytes.36;
    GC_non_gc_bytes = GC_non_gc_bytes.37;
    GC_clear (&GC_allocate_lock);
    D.8103 = op;
    return D.8103;
  }
}