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

  switch (knd) <default: <D.5552>, case 0: <D.5548>, case 1: <D.5549>, case 2: <D.5550>, case 3: <D.5551>>
  <D.5548>:
  D.5649 = GC_malloc_atomic (lb);
  return D.5649;
  <D.5549>:
  D.5649 = GC_malloc (lb);
  return D.5649;
  <D.5550>:
  D.5649 = GC_malloc_uncollectable (lb);
  return D.5649;
  <D.5551>:
  D.5649 = GC_malloc_atomic_uncollectable (lb);
  return D.5649;
  <D.5552>:
  D.5649 = GC_generic_malloc (lb, knd);
  return D.5649;
}


GC_realloc (void * p, size_t lb)
{
  void * D.5653;
  long unsigned int p.0;
  long unsigned int D.5655;
  unsigned char D.5656;
  long unsigned int D.5659;
  long unsigned int D.5660;
  int D.5661;
  int D.5664;
  long unsigned int D.5667;
  long unsigned int GC_non_gc_bytes.1;
  long unsigned int GC_non_gc_bytes.2;
  int GC_all_interior_pointers.3;
  long unsigned int D.5671;
  long unsigned int D.5672;
  long unsigned int D.5675;
  long unsigned int D.5680;
  void * D.5681;
  register struct hblk * h;
  register struct hdr * hhdr;
  register word sz;
  register word orig_sz;
  int obj_kind;

  if (p == 0B) goto <D.5651>; else goto <D.5652>;
  <D.5651>:
  D.5653 = GC_malloc (lb);
  return D.5653;
  <D.5652>:
  p.0 = (long unsigned int) p;
  D.5655 = p.0 & 18446744073709547520;
  h = (struct hblk *) D.5655;
  hhdr = GC_find_header (h);
  sz = hhdr->hb_sz;
  D.5656 = hhdr->hb_obj_kind;
  obj_kind = (int) D.5656;
  sz = sz << 3;
  orig_sz = sz;
  if (sz > 2048) goto <D.5657>; else goto <D.5658>;
  <D.5657>:
  {
    register word descr;

    D.5659 = sz + 4095;
    sz = D.5659 & 18446744073709547520;
    D.5660 = sz >> 3;
    hhdr->hb_sz = D.5660;
    descr = GC_obj_kinds[obj_kind].ok_descriptor;
    D.5661 = GC_obj_kinds[obj_kind].ok_relocate_descr;
    if (D.5661 != 0) goto <D.5662>; else goto <D.5663>;
    <D.5662>:
    descr = descr + sz;
    <D.5663>:
    hhdr->hb_descr = descr;
    D.5664 = obj_kind & -2;
    if (D.5664 == 2) goto <D.5665>; else goto <D.5666>;
    <D.5665>:
    D.5667 = sz - orig_sz;
    GC_non_gc_bytes.1 = GC_non_gc_bytes;
    GC_non_gc_bytes.2 = D.5667 + GC_non_gc_bytes.1;
    GC_non_gc_bytes = GC_non_gc_bytes.2;
    <D.5666>:
  }
  <D.5658>:
  GC_all_interior_pointers.3 = GC_all_interior_pointers;
  D.5671 = (long unsigned int) GC_all_interior_pointers.3;
  D.5672 = D.5671 + lb;
  if (D.5672 <= sz) goto <D.5673>; else goto <D.5674>;
  <D.5673>:
  D.5675 = sz >> 1;
  if (D.5675 <= lb) goto <D.5676>; else goto <D.5677>;
  <D.5676>:
  if (orig_sz > lb) goto <D.5678>; else goto <D.5679>;
  <D.5678>:
  D.5680 = orig_sz - lb;
  D.5681 = p + lb;
  memset (D.5681, 0, D.5680);
  <D.5679>:
  D.5653 = p;
  return D.5653;
  <D.5677>:
  {
    void * result;

    result = GC_generic_or_special_malloc (lb, obj_kind);
    if (result == 0B) goto <D.5682>; else goto <D.5683>;
    <D.5682>:
    D.5653 = 0B;
    return D.5653;
    <D.5683>:
    memcpy (result, p, lb);
    GC_free (p);
    D.5653 = result;
    return D.5653;
  }
  <D.5674>:
  {
    void * result;

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.5689;
  int D.5694;
  void * D.5696;
  long unsigned int D.5697;

  D.5689 = __builtin_constant_p (__len);
  if (D.5689 != 0) goto <D.5690>; else goto <D.5691>;
  <D.5690>:
  if (__len == 0) goto <D.5692>; else goto <D.5693>;
  <D.5692>:
  D.5694 = __builtin_constant_p (__ch);
  if (D.5694 == 0) goto <D.5687>; else goto <D.5695>;
  <D.5695>:
  if (__ch != 0) goto <D.5687>; else goto <D.5688>;
  <D.5687>:
  __warn_memset_zero_len ();
  D.5696 = __dest;
  return D.5696;
  <D.5688>:
  <D.5693>:
  <D.5691>:
  D.5697 = __builtin_object_size (__dest, 0);
  D.5696 = __builtin___memset_chk (__dest, __ch, __len, D.5697);
  return D.5696;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.5699;
  long unsigned int D.5700;

  D.5700 = __builtin_object_size (__dest, 0);
  D.5699 = __builtin___memcpy_chk (__dest, __src, __len, D.5700);
  return D.5699;
}


GC_generic_malloc_ignore_off_page (size_t lb, int k)
{
  int GC_all_interior_pointers.4;
  long unsigned int D.5703;
  long unsigned int D.5704;
  char * D.5707;
  int D.5708;
  long unsigned int D.5709;
  long unsigned int D.5710;
  long unsigned int D.5711;
  long unsigned int D.5712;
  int GC_have_errors.5;
  int D.5716;
  int GC_debugging_started.6;
  long unsigned int D.5724;
  word * D.5726;
  long unsigned int D.5727;
  sizetype D.5728;
  word * D.5729;
  sizetype D.5730;
  word * D.5731;
  long unsigned int D.5732;
  long unsigned int D.5733;
  void * (*<T6ee>) (size_t) GC_oom_fn.7;
  register char * result;
  word lw;
  word n_blocks;
  GC_bool init;

  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  D.5703 = (long unsigned int) GC_all_interior_pointers.4;
  D.5704 = 2048 - D.5703;
  if (D.5704 >= lb) goto <D.5705>; else goto <D.5706>;
  <D.5705>:
  D.5707 = GC_generic_malloc (lb, k);
  return D.5707;
  <D.5706>:
  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  D.5708 = GC_all_interior_pointers.4 + 7;
  D.5709 = (long unsigned int) D.5708;
  D.5710 = D.5709 + lb;
  lw = D.5710 >> 3;
  D.5711 = lw << 3;
  D.5712 = D.5711 + 4095;
  n_blocks = D.5712 >> 12;
  init = GC_obj_kinds[k].ok_init;
  GC_have_errors.5 = GC_have_errors;
  if (GC_have_errors.5 != 0) goto <D.5714>; else goto <D.5715>;
  <D.5714>:
  GC_print_all_errors ();
  <D.5715>:
  GC_notify_or_invoke_finalizers ();
  D.5716 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5716 != 0) goto <D.5717>; else goto <D.5718>;
  <D.5717>:
  GC_lock ();
  <D.5718>:
  result = GC_alloc_large (lw, k, 1);
  if (result != 0B) goto <D.5719>; else goto <D.5720>;
  <D.5719>:
  GC_debugging_started.6 = GC_debugging_started;
  if (GC_debugging_started.6 != 0) goto <D.5722>; else goto <D.5723>;
  <D.5722>:
  D.5724 = n_blocks * 4096;
  memset (result, 0, D.5724);
  goto <D.5725>;
  <D.5723>:
  MEM[(word *)result] = 0;
  D.5726 = result + 8;
  *D.5726 = 0;
  D.5727 = lw * 8;
  D.5728 = D.5727 + 18446744073709551608;
  D.5729 = result + D.5728;
  *D.5729 = 0;
  D.5727 = lw * 8;
  D.5730 = D.5727 + 18446744073709551600;
  D.5731 = result + D.5730;
  *D.5731 = 0;
  <D.5725>:
  <D.5720>:
  D.5732 = GC_arrays._words_allocd;
  D.5733 = D.5732 + lw;
  GC_arrays._words_allocd = D.5733;
  pthread_mutex_unlock (&GC_allocate_ml);
  if (result == 0B) goto <D.5734>; else goto <D.5735>;
  <D.5734>:
  GC_oom_fn.7 = GC_oom_fn;
  D.5707 = GC_oom_fn.7 (lb);
  return D.5707;
  <D.5735>:
  if (init != 0) goto <D.5737>; else goto <D.5738>;
  <D.5737>:
  GC_debugging_started.6 = GC_debugging_started;
  if (GC_debugging_started.6 == 0) goto <D.5739>; else goto <D.5740>;
  <D.5739>:
  D.5724 = n_blocks * 4096;
  memset (result, 0, D.5724);
  <D.5740>:
  <D.5738>:
  D.5707 = result;
  return D.5707;
}


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

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


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

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


GC_incr_words_allocd (size_t n)
{
  long unsigned int D.5746;
  long unsigned int D.5747;

  D.5746 = GC_arrays._words_allocd;
  D.5747 = D.5746 + n;
  GC_arrays._words_allocd = D.5747;
}


GC_incr_mem_freed (size_t n)
{
  long unsigned int D.5748;
  long unsigned int D.5749;

  D.5748 = GC_arrays._mem_freed;
  D.5749 = D.5748 + n;
  GC_arrays._mem_freed = D.5749;
}


GC_generic_malloc_words_small_inner (word lw, int k)
{
  long unsigned int D.5750;
  long unsigned int D.5751;
  char * * D.5752;
  long unsigned int D.5753;
  int GC_is_initialized.8;
  struct hblk * * D.5761;
  int D.5763;
  char * D.5764;
  char * D.5767;
  void * (*<T6ee>) (size_t) GC_oom_fn.9;
  long unsigned int D.5769;
  char * D.5770;
  long unsigned int D.5771;
  long unsigned int D.5772;
  register char * op;
  register char * * opp;
  register struct obj_kind * kind;

  D.5750 = (long unsigned int) k;
  D.5751 = D.5750 * 32;
  kind = &GC_obj_kinds + D.5751;
  D.5752 = kind->ok_freelist;
  D.5753 = lw * 8;
  opp = D.5752 + D.5753;
  op = *opp;
  if (op == 0B) goto <D.5754>; else goto <D.5755>;
  <D.5754>:
  GC_is_initialized.8 = GC_is_initialized;
  if (GC_is_initialized.8 == 0) goto <D.5757>; else goto <D.5758>;
  <D.5757>:
  GC_init_inner ();
  <D.5758>:
  D.5761 = kind->ok_reclaim_list;
  if (D.5761 != 0B) goto <D.5759>; else goto <D.5762>;
  <D.5762>:
  D.5763 = GC_alloc_reclaim_list (kind);
  if (D.5763 != 0) goto <D.5759>; else goto <D.5760>;
  <D.5759>:
  D.5764 = GC_allocobj (lw, k);
  op = GC_clear_stack (D.5764);
  <D.5760>:
  if (op == 0B) goto <D.5765>; else goto <D.5766>;
  <D.5765>:
  pthread_mutex_unlock (&GC_allocate_ml);
  GC_oom_fn.9 = GC_oom_fn;
  D.5769 = lw << 3;
  D.5767 = GC_oom_fn.9 (D.5769);
  return D.5767;
  <D.5766>:
  <D.5755>:
  D.5770 = MEM[(char * *)op];
  *opp = D.5770;
  MEM[(char * *)op] = 0B;
  D.5771 = GC_arrays._words_allocd;
  D.5772 = D.5771 + lw;
  GC_arrays._words_allocd = D.5772;
  D.5767 = op;
  return D.5767;
}


GC_generic_malloc_words_small (size_t lw, int k)
{
  int GC_have_errors.10;
  int D.5777;
  char * D.5780;
  register char * op;

  GC_have_errors.10 = GC_have_errors;
  if (GC_have_errors.10 != 0) goto <D.5775>; else goto <D.5776>;
  <D.5775>:
  GC_print_all_errors ();
  <D.5776>:
  GC_notify_or_invoke_finalizers ();
  D.5777 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5777 != 0) goto <D.5778>; else goto <D.5779>;
  <D.5778>:
  GC_lock ();
  <D.5779>:
  op = GC_generic_malloc_words_small_inner (lw, k);
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5780 = op;
  return D.5780;
}


GC_generic_malloc_many (word lb, int k, char * * result)
{
  int GC_all_interior_pointers.11;
  long unsigned int D.5783;
  long unsigned int D.5784;
  int D.5789;
  long unsigned int D.5790;
  long unsigned int D.5791;
  int GC_have_errors.12;
  int D.5795;
  int GC_is_initialized.13;
  int GC_incremental.14;
  int GC_dont_gc.15;
  long unsigned int D.5807;
  struct hblk * D.5808;
  long unsigned int GC_gc_no.16;
  short unsigned int D.5810;
  long int D.5813;
  long unsigned int D.5814;
  long unsigned int D.5815;
  long unsigned int my_words_allocd_tmp.17;
  long unsigned int D.5817;
  long unsigned int GC_fl_builder_count.18;
  long unsigned int GC_fl_builder_count.19;
  int D.5820;
  long unsigned int my_words_allocd.20;
  long unsigned int GC_fl_builder_count.21;
  int D.5829;
  char * * D.5832;
  long unsigned int my_words_allocd.22;
  char * D.5838;
  long unsigned int D.5839;
  int D.5842;
  struct hdr * D.5845;
  long unsigned int D.5846;
  long unsigned int D.5847;
  long unsigned int D.5848;
  char * op;
  char * p;
  char * * opp;
  word lw;
  word my_words_allocd;
  struct obj_kind * ok;
  void out = <<< error >>>;

  try
    {
      my_words_allocd = 0;
      ok = &GC_obj_kinds[k];
      GC_all_interior_pointers.11 = GC_all_interior_pointers;
      D.5783 = (long unsigned int) GC_all_interior_pointers.11;
      D.5784 = 2048 - D.5783;
      if (D.5784 < lb) goto <D.5785>; else goto <D.5786>;
      <D.5785>:
      op = GC_generic_malloc (lb, k);
      if (op != 0B) goto <D.5787>; else goto <D.5788>;
      <D.5787>:
      MEM[(char * *)op] = 0B;
      <D.5788>:
      *result = op;
      return;
      <D.5786>:
      GC_all_interior_pointers.11 = GC_all_interior_pointers;
      D.5789 = GC_all_interior_pointers.11 + 7;
      D.5790 = (long unsigned int) D.5789;
      D.5791 = D.5790 + lb;
      lw = D.5791 >> 3;
      GC_have_errors.12 = GC_have_errors;
      if (GC_have_errors.12 != 0) goto <D.5793>; else goto <D.5794>;
      <D.5793>:
      GC_print_all_errors ();
      <D.5794>:
      GC_notify_or_invoke_finalizers ();
      D.5795 = pthread_mutex_trylock (&GC_allocate_ml);
      if (D.5795 != 0) goto <D.5796>; else goto <D.5797>;
      <D.5796>:
      GC_lock ();
      <D.5797>:
      GC_is_initialized.13 = GC_is_initialized;
      if (GC_is_initialized.13 == 0) goto <D.5799>; else goto <D.5800>;
      <D.5799>:
      GC_init_inner ();
      <D.5800>:
      GC_incremental.14 = GC_incremental;
      if (GC_incremental.14 != 0) goto <D.5802>; else goto <D.5803>;
      <D.5802>:
      GC_dont_gc.15 = GC_dont_gc;
      if (GC_dont_gc.15 == 0) goto <D.5805>; else goto <D.5806>;
      <D.5805>:
      GC_collecting = 1;
      GC_collect_a_little_inner (1);
      GC_collecting = 0;
      <D.5806>:
      <D.5803>:
      {
        struct hblk * * rlh;
        struct hblk * hbp;
        struct hdr * hhdr;

        rlh = ok->ok_reclaim_list;
        D.5807 = lw * 8;
        rlh = rlh + D.5807;
        goto <D.5616>;
        <D.5615>:
        hhdr = GC_find_header (hbp);
        D.5808 = hhdr->hb_next;
        *rlh = D.5808;
        GC_gc_no.16 = GC_gc_no;
        D.5810 = (short unsigned int) GC_gc_no.16;
        hhdr->hb_last_reclaimed = D.5810;
        {
          signed_word my_words_allocd_tmp;

          my_words_allocd_tmp = GC_words_allocd_tmp;
          if (my_words_allocd_tmp != 0) goto <D.5811>; else goto <D.5812>;
          <D.5811>:
          D.5813 = -my_words_allocd_tmp;
          D.5814 = (long unsigned int) D.5813;
          GC_atomic_add (&GC_words_allocd_tmp, D.5814);
          D.5815 = GC_arrays._words_allocd;
          my_words_allocd_tmp.17 = (long unsigned int) my_words_allocd_tmp;
          D.5817 = D.5815 + my_words_allocd_tmp.17;
          GC_arrays._words_allocd = D.5817;
          <D.5812>:
        }
        GC_acquire_mark_lock ();
        GC_fl_builder_count.18 = GC_fl_builder_count;
        GC_fl_builder_count.19 = GC_fl_builder_count.18 + 1;
        GC_fl_builder_count = GC_fl_builder_count.19;
        pthread_mutex_unlock (&GC_allocate_ml);
        GC_release_mark_lock ();
        D.5820 = ok->ok_init;
        op = GC_reclaim_generic (hbp, hhdr, lw, D.5820, 0, &my_words_allocd);
        if (op != 0B) goto <D.5821>; else goto <D.5822>;
        <D.5821>:
        *result = op;
        my_words_allocd.20 = my_words_allocd;
        GC_atomic_add (&GC_words_allocd_tmp, my_words_allocd.20);
        GC_acquire_mark_lock ();
        GC_fl_builder_count.18 = GC_fl_builder_count;
        GC_fl_builder_count.21 = GC_fl_builder_count.18 + 18446744073709551615;
        GC_fl_builder_count = GC_fl_builder_count.21;
        GC_fl_builder_count.18 = GC_fl_builder_count;
        if (GC_fl_builder_count.18 == 0) goto <D.5825>; else goto <D.5826>;
        <D.5825>:
        GC_notify_all_builder ();
        <D.5826>:
        GC_release_mark_lock ();
        GC_clear_stack (0);
        return;
        <D.5822>:
        GC_acquire_mark_lock ();
        GC_fl_builder_count.18 = GC_fl_builder_count;
        GC_fl_builder_count.21 = GC_fl_builder_count.18 + 18446744073709551615;
        GC_fl_builder_count = GC_fl_builder_count.21;
        GC_fl_builder_count.18 = GC_fl_builder_count;
        if (GC_fl_builder_count.18 == 0) goto <D.5827>; else goto <D.5828>;
        <D.5827>:
        GC_notify_all_builder ();
        <D.5828>:
        GC_release_mark_lock ();
        D.5829 = pthread_mutex_trylock (&GC_allocate_ml);
        if (D.5829 != 0) goto <D.5830>; else goto <D.5831>;
        <D.5830>:
        GC_lock ();
        <D.5831>:
        <D.5616>:
        hbp = *rlh;
        if (hbp != 0B) goto <D.5615>; else goto <D.5617>;
        <D.5617>:
      }
      D.5832 = GC_obj_kinds[k].ok_freelist;
      D.5807 = lw * 8;
      opp = D.5832 + D.5807;
      op = *opp;
      if (op != 0B) goto <D.5833>; else goto <D.5834>;
      <D.5833>:
      *opp = 0B;
      my_words_allocd = 0;
      p = op;
      goto <D.5620>;
      <D.5619>:
      my_words_allocd.20 = my_words_allocd;
      my_words_allocd.22 = my_words_allocd.20 + lw;
      my_words_allocd = my_words_allocd.22;
      my_words_allocd.20 = my_words_allocd;
      if (my_words_allocd.20 > 511) goto <D.5836>; else goto <D.5837>;
      <D.5836>:
      D.5838 = MEM[(char * *)p];
      *opp = D.5838;
      MEM[(char * *)p] = 0B;
      goto <D.5618>;
      <D.5837>:
      p = MEM[(char * *)p];
      <D.5620>:
      if (p != 0B) goto <D.5619>; else goto <D.5618>;
      <D.5618>:
      D.5815 = GC_arrays._words_allocd;
      my_words_allocd.20 = my_words_allocd;
      D.5839 = D.5815 + my_words_allocd.20;
      GC_arrays._words_allocd = D.5839;
      goto out;
      <D.5834>:
      {
        struct hblk * h;

        h = GC_allochblk (lw, k, 0);
        if (h != 0B) goto <D.5840>; else goto <D.5841>;
        <D.5840>:
        D.5842 = k & -2;
        if (D.5842 == 2) goto <D.5843>; else goto <D.5844>;
        <D.5843>:
        D.5845 = GC_find_header (h);
        GC_set_hdr_marks (D.5845);
        <D.5844>:
        D.5815 = GC_arrays._words_allocd;
        D.5846 = 512 % lw;
        D.5847 = D.5815 - D.5846;
        D.5848 = D.5847 + 512;
        GC_arrays._words_allocd = D.5848;
        GC_acquire_mark_lock ();
        GC_fl_builder_count.18 = GC_fl_builder_count;
        GC_fl_builder_count.19 = GC_fl_builder_count.18 + 1;
        GC_fl_builder_count = GC_fl_builder_count.19;
        pthread_mutex_unlock (&GC_allocate_ml);
        GC_release_mark_lock ();
        D.5820 = ok->ok_init;
        op = GC_build_fl (h, lw, D.5820, 0B);
        *result = op;
        GC_acquire_mark_lock ();
        GC_fl_builder_count.18 = GC_fl_builder_count;
        GC_fl_builder_count.21 = GC_fl_builder_count.18 + 18446744073709551615;
        GC_fl_builder_count = GC_fl_builder_count.21;
        GC_fl_builder_count.18 = GC_fl_builder_count;
        if (GC_fl_builder_count.18 == 0) goto <D.5849>; else goto <D.5850>;
        <D.5849>:
        GC_notify_all_builder ();
        <D.5850>:
        GC_release_mark_lock ();
        GC_clear_stack (0);
        return;
        <D.5841>:
      }
      op = GC_generic_malloc_inner (lb, k);
      if (op != 0B) goto <D.5851>; else goto <D.5852>;
      <D.5851>:
      MEM[(char * *)op] = 0B;
      <D.5852>:
      out:
      *result = op;
      pthread_mutex_unlock (&GC_allocate_ml);
      GC_clear_stack (0);
    }
  finally
    {
      my_words_allocd = {CLOBBER};
    }
}


GC_atomic_add (volatile GC_word * addr, GC_word how_much)
{
  long unsigned int D.5856;
  int D.5857;
  GC_word D.5858;
  GC_word old;

  <D.4664>:
  old = *addr;
  D.5856 = old + how_much;
  D.5857 = GC_compare_and_exchange (addr, old, D.5856);
  if (D.5857 == 0) goto <D.4664>; else goto <D.4665>;
  <D.4665>:
  D.5858 = old;
  return D.5858;
}


GC_compare_and_exchange (volatile GC_word * addr, GC_word old, GC_word new_val)
{
  GC_bool D.5860;
  char result;

  __asm__ __volatile__("lock; cmpxchgq %2, %0; setz %1" : "=m" *addr, "=r" result : "r" new_val, "a" old, "m" *addr : "memory");
  D.5860 = (GC_bool) result;
  return D.5860;
}


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

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


GC_malloc_uncollectable (size_t lb)
{
  int GC_all_interior_pointers.23;
  long unsigned int D.5866;
  long unsigned int D.5867;
  unsigned int D.5874;
  int D.5875;
  char * D.5880;
  long unsigned int D.5881;
  long unsigned int D.5882;
  long unsigned int D.5883;
  long unsigned int GC_non_gc_bytes.24;
  long unsigned int GC_non_gc_bytes.25;
  void * D.5886;
  long unsigned int op.26;
  long unsigned int D.5891;
  struct hdr * D.5892;
  int D.5893;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.23 = GC_all_interior_pointers;
  D.5866 = (long unsigned int) GC_all_interior_pointers.23;
  D.5867 = 2048 - D.5866;
  if (D.5867 >= lb) goto <D.5868>; else goto <D.5869>;
  <D.5868>:
  GC_all_interior_pointers.23 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.23 != 0) goto <D.5870>; else goto <D.5871>;
  <D.5870>:
  if (lb != 0) goto <D.5872>; else goto <D.5873>;
  <D.5872>:
  lb = lb + 18446744073709551615;
  <D.5873>:
  <D.5871>:
  D.5874 = GC_arrays._size_map[lb];
  lw = (word) D.5874;
  opp = &GC_arrays._uobjfreelist[lw];
  D.5875 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5875 != 0) goto <D.5876>; else goto <D.5877>;
  <D.5876>:
  GC_lock ();
  <D.5877>:
  op = *opp;
  if (op != 0B) goto <D.5878>; else goto <D.5879>;
  <D.5878>:
  D.5880 = MEM[(char * *)op];
  *opp = D.5880;
  MEM[(char * *)op] = 0B;
  D.5881 = GC_arrays._words_allocd;
  D.5882 = D.5881 + lw;
  GC_arrays._words_allocd = D.5882;
  D.5883 = lw << 3;
  GC_non_gc_bytes.24 = GC_non_gc_bytes;
  GC_non_gc_bytes.25 = D.5883 + GC_non_gc_bytes.24;
  GC_non_gc_bytes = GC_non_gc_bytes.25;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5886 = op;
  return D.5886;
  <D.5879>:
  pthread_mutex_unlock (&GC_allocate_ml);
  op = GC_generic_malloc (lb, 2);
  goto <D.5887>;
  <D.5869>:
  op = GC_generic_malloc (lb, 2);
  <D.5887>:
  if (op == 0B) goto <D.5888>; else goto <D.5889>;
  <D.5888>:
  D.5886 = 0B;
  return D.5886;
  <D.5889>:
  {
    register struct hblk * h;

    op.26 = (long unsigned int) op;
    D.5891 = op.26 & 18446744073709547520;
    h = (struct hblk *) D.5891;
    D.5892 = GC_find_header (h);
    lw = D.5892->hb_sz;
    D.5893 = pthread_mutex_trylock (&GC_allocate_ml);
    if (D.5893 != 0) goto <D.5894>; else goto <D.5895>;
    <D.5894>:
    GC_lock ();
    <D.5895>:
    GC_set_mark_bit (op);
    D.5883 = lw << 3;
    GC_non_gc_bytes.24 = GC_non_gc_bytes;
    GC_non_gc_bytes.25 = D.5883 + GC_non_gc_bytes.24;
    GC_non_gc_bytes = GC_non_gc_bytes.25;
    pthread_mutex_unlock (&GC_allocate_ml);
    D.5886 = op;
    return D.5886;
  }
}


GC_memalign (size_t align, size_t lb)
{
  void * D.5899;
  _Bool D.5900;
  _Bool D.5901;
  _Bool D.5902;
  void * (*<T6ee>) (size_t) GC_oom_fn.27;
  long unsigned int D.5908;
  long unsigned int D.5909;
  long unsigned int result.28;
  int GC_all_interior_pointers.29;
  size_t new_lb;
  size_t offset;
  char * result;

  if (align <= 8) goto <D.5897>; else goto <D.5898>;
  <D.5897>:
  D.5899 = GC_malloc (lb);
  return D.5899;
  <D.5898>:
  D.5900 = align > 2047;
  D.5901 = lb > 2047;
  D.5902 = D.5900 | D.5901;
  if (D.5902 != 0) goto <D.5903>; else goto <D.5904>;
  <D.5903>:
  if (align > 4096) goto <D.5905>; else goto <D.5906>;
  <D.5905>:
  GC_oom_fn.27 = GC_oom_fn;
  D.5899 = GC_oom_fn.27 (9223372036854774783);
  return D.5899;
  <D.5906>:
  D.5908 = MAX_EXPR <lb, 4096>;
  D.5899 = GC_malloc (D.5908);
  return D.5899;
  <D.5904>:
  D.5909 = lb + align;
  new_lb = D.5909 + 18446744073709551615;
  result = GC_malloc (new_lb);
  result.28 = (long unsigned int) result;
  offset = result.28 % align;
  if (offset != 0) goto <D.5911>; else goto <D.5912>;
  <D.5911>:
  offset = align - offset;
  GC_all_interior_pointers.29 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.29 == 0) goto <D.5914>; else goto <D.5915>;
  <D.5914>:
  if (offset > 2048) goto <D.5916>; else goto <D.5917>;
  <D.5916>:
  D.5899 = GC_malloc (4096);
  return D.5899;
  <D.5917>:
  GC_register_displacement (offset);
  <D.5915>:
  <D.5912>:
  result = result + offset;
  D.5899 = result;
  return D.5899;
}


GC_malloc_atomic_uncollectable (size_t lb)
{
  int GC_all_interior_pointers.30;
  long unsigned int D.5920;
  long unsigned int D.5921;
  unsigned int D.5928;
  int D.5929;
  char * D.5934;
  long unsigned int D.5935;
  long unsigned int D.5936;
  long unsigned int D.5937;
  long unsigned int GC_non_gc_bytes.31;
  long unsigned int GC_non_gc_bytes.32;
  void * D.5940;
  long unsigned int op.33;
  long unsigned int D.5945;
  struct hdr * D.5946;
  int D.5947;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.30 = GC_all_interior_pointers;
  D.5920 = (long unsigned int) GC_all_interior_pointers.30;
  D.5921 = 2048 - D.5920;
  if (D.5921 >= lb) goto <D.5922>; else goto <D.5923>;
  <D.5922>:
  GC_all_interior_pointers.30 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.30 != 0) goto <D.5924>; else goto <D.5925>;
  <D.5924>:
  if (lb != 0) goto <D.5926>; else goto <D.5927>;
  <D.5926>:
  lb = lb + 18446744073709551615;
  <D.5927>:
  <D.5925>:
  D.5928 = GC_arrays._size_map[lb];
  lw = (word) D.5928;
  opp = &GC_arrays._auobjfreelist[lw];
  D.5929 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5929 != 0) goto <D.5930>; else goto <D.5931>;
  <D.5930>:
  GC_lock ();
  <D.5931>:
  op = *opp;
  if (op != 0B) goto <D.5932>; else goto <D.5933>;
  <D.5932>:
  D.5934 = MEM[(char * *)op];
  *opp = D.5934;
  MEM[(char * *)op] = 0B;
  D.5935 = GC_arrays._words_allocd;
  D.5936 = D.5935 + lw;
  GC_arrays._words_allocd = D.5936;
  D.5937 = lw << 3;
  GC_non_gc_bytes.31 = GC_non_gc_bytes;
  GC_non_gc_bytes.32 = D.5937 + GC_non_gc_bytes.31;
  GC_non_gc_bytes = GC_non_gc_bytes.32;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5940 = op;
  return D.5940;
  <D.5933>:
  pthread_mutex_unlock (&GC_allocate_ml);
  op = GC_generic_malloc (lb, 3);
  goto <D.5941>;
  <D.5923>:
  op = GC_generic_malloc (lb, 3);
  <D.5941>:
  if (op == 0B) goto <D.5942>; else goto <D.5943>;
  <D.5942>:
  D.5940 = 0B;
  return D.5940;
  <D.5943>:
  {
    register struct hblk * h;

    op.33 = (long unsigned int) op;
    D.5945 = op.33 & 18446744073709547520;
    h = (struct hblk *) D.5945;
    D.5946 = GC_find_header (h);
    lw = D.5946->hb_sz;
    D.5947 = pthread_mutex_trylock (&GC_allocate_ml);
    if (D.5947 != 0) goto <D.5948>; else goto <D.5949>;
    <D.5948>:
    GC_lock ();
    <D.5949>:
    GC_set_mark_bit (op);
    D.5937 = lw << 3;
    GC_non_gc_bytes.31 = GC_non_gc_bytes;
    GC_non_gc_bytes.32 = D.5937 + GC_non_gc_bytes.31;
    GC_non_gc_bytes = GC_non_gc_bytes.32;
    pthread_mutex_unlock (&GC_allocate_ml);
    D.5940 = op;
    return D.5940;
  }
}