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

  switch (knd) <default: <D.5634>, case 0: <D.5630>, case 1: <D.5631>, case 2: <D.5632>, case 3: <D.5633>>
  <D.5630>:
  D.5731 = GC_malloc_atomic (lb);
  return D.5731;
  <D.5631>:
  D.5731 = GC_malloc (lb);
  return D.5731;
  <D.5632>:
  D.5731 = GC_malloc_uncollectable (lb);
  return D.5731;
  <D.5633>:
  D.5731 = GC_malloc_atomic_uncollectable (lb);
  return D.5731;
  <D.5634>:
  D.5731 = GC_generic_malloc (lb, knd);
  return D.5731;
}


GC_realloc (void * p, size_t lb)
{
  void * D.5735;
  long unsigned int p.0;
  long unsigned int D.5737;
  unsigned char D.5738;
  long unsigned int D.5741;
  long unsigned int D.5742;
  int D.5743;
  int D.5746;
  long unsigned int D.5749;
  long unsigned int GC_non_gc_bytes.1;
  long unsigned int D.5751;
  int GC_all_interior_pointers.2;
  long unsigned int D.5753;
  long unsigned int D.5754;
  long unsigned int D.5757;
  void * D.5762;
  long unsigned int D.5763;
  register struct hblk * h;
  register struct hdr * hhdr;
  register word sz;
  register word orig_sz;
  int obj_kind;

  if (p == 0B) goto <D.5733>; else goto <D.5734>;
  <D.5733>:
  D.5735 = GC_malloc (lb);
  return D.5735;
  <D.5734>:
  p.0 = (long unsigned int) p;
  D.5737 = p.0 & 18446744073709547520;
  h = (struct hblk *) D.5737;
  hhdr = GC_find_header (h);
  sz = hhdr->hb_sz;
  D.5738 = hhdr->hb_obj_kind;
  obj_kind = (int) D.5738;
  sz = sz << 3;
  orig_sz = sz;
  if (sz > 2048) goto <D.5739>; else goto <D.5740>;
  <D.5739>:
  {
    register word descr;

    D.5741 = sz + 4095;
    sz = D.5741 & 18446744073709547520;
    D.5742 = sz >> 3;
    hhdr->hb_sz = D.5742;
    descr = GC_obj_kinds[obj_kind].ok_descriptor;
    D.5743 = GC_obj_kinds[obj_kind].ok_relocate_descr;
    if (D.5743 != 0) goto <D.5744>; else goto <D.5745>;
    <D.5744>:
    descr = descr + sz;
    <D.5745>:
    hhdr->hb_descr = descr;
    D.5746 = obj_kind & -2;
    if (D.5746 == 2) goto <D.5747>; else goto <D.5748>;
    <D.5747>:
    D.5749 = sz - orig_sz;
    GC_non_gc_bytes.1 = GC_non_gc_bytes;
    D.5751 = D.5749 + GC_non_gc_bytes.1;
    GC_non_gc_bytes = D.5751;
    <D.5748>:
  }
  <D.5740>:
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  D.5753 = (long unsigned int) GC_all_interior_pointers.2;
  D.5754 = D.5753 + lb;
  if (D.5754 <= sz) goto <D.5755>; else goto <D.5756>;
  <D.5755>:
  D.5757 = sz >> 1;
  if (D.5757 <= lb) goto <D.5758>; else goto <D.5759>;
  <D.5758>:
  if (orig_sz > lb) goto <D.5760>; else goto <D.5761>;
  <D.5760>:
  D.5762 = p + lb;
  D.5763 = orig_sz - lb;
  memset (D.5762, 0, D.5763);
  <D.5761>:
  D.5735 = p;
  return D.5735;
  <D.5759>:
  {
    void * result;

    result = GC_generic_or_special_malloc (lb, obj_kind);
    if (result == 0B) goto <D.5764>; else goto <D.5765>;
    <D.5764>:
    D.5735 = 0B;
    return D.5735;
    <D.5765>:
    memcpy (result, p, lb);
    GC_free (p);
    D.5735 = result;
    return D.5735;
  }
  <D.5756>:
  {
    void * result;

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


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

  D.5770 = __builtin_object_size (__dest, 0);
  D.5769 = __builtin___memset_chk (__dest, __ch, __len, D.5770);
  return D.5769;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.5772;
  long unsigned int D.5773;

  D.5773 = __builtin_object_size (__dest, 0);
  D.5772 = __builtin___memcpy_chk (__dest, __src, __len, D.5773);
  return D.5772;
}


GC_generic_malloc_ignore_off_page (size_t lb, int k)
{
  int GC_all_interior_pointers.3;
  long unsigned int D.5776;
  long unsigned int D.5777;
  char * D.5780;
  int D.5781;
  long unsigned int D.5782;
  long unsigned int D.5783;
  long unsigned int D.5784;
  long unsigned int D.5785;
  int GC_have_errors.4;
  int D.5789;
  int GC_debugging_started.5;
  long unsigned int D.5797;
  word * D.5799;
  long unsigned int D.5800;
  sizetype D.5801;
  word * D.5802;
  sizetype D.5803;
  word * D.5804;
  long unsigned int D.5805;
  long unsigned int D.5806;
  void * (*<T764>) (size_t) GC_oom_fn.6;
  register char * result;
  word lw;
  word n_blocks;
  GC_bool init;

  GC_all_interior_pointers.3 = GC_all_interior_pointers;
  D.5776 = (long unsigned int) GC_all_interior_pointers.3;
  D.5777 = 2048 - D.5776;
  if (D.5777 >= lb) goto <D.5778>; else goto <D.5779>;
  <D.5778>:
  D.5780 = GC_generic_malloc (lb, k);
  return D.5780;
  <D.5779>:
  GC_all_interior_pointers.3 = GC_all_interior_pointers;
  D.5781 = GC_all_interior_pointers.3 + 7;
  D.5782 = (long unsigned int) D.5781;
  D.5783 = D.5782 + lb;
  lw = D.5783 >> 3;
  D.5784 = lw << 3;
  D.5785 = D.5784 + 4095;
  n_blocks = D.5785 >> 12;
  init = GC_obj_kinds[k].ok_init;
  GC_have_errors.4 = GC_have_errors;
  if (GC_have_errors.4 != 0) goto <D.5787>; else goto <D.5788>;
  <D.5787>:
  GC_print_all_errors ();
  <D.5788>:
  GC_notify_or_invoke_finalizers ();
  D.5789 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5789 != 0) goto <D.5790>; else goto <D.5791>;
  <D.5790>:
  GC_lock ();
  <D.5791>:
  result = GC_alloc_large (lw, k, 1);
  if (result != 0B) goto <D.5792>; else goto <D.5793>;
  <D.5792>:
  GC_debugging_started.5 = GC_debugging_started;
  if (GC_debugging_started.5 != 0) goto <D.5795>; else goto <D.5796>;
  <D.5795>:
  D.5797 = n_blocks * 4096;
  memset (result, 0, D.5797);
  goto <D.5798>;
  <D.5796>:
  MEM[(word *)result] = 0;
  D.5799 = result + 8;
  *D.5799 = 0;
  D.5800 = lw * 8;
  D.5801 = D.5800 + 18446744073709551608;
  D.5802 = result + D.5801;
  *D.5802 = 0;
  D.5800 = lw * 8;
  D.5803 = D.5800 + 18446744073709551600;
  D.5804 = result + D.5803;
  *D.5804 = 0;
  <D.5798>:
  <D.5793>:
  D.5805 = GC_arrays._words_allocd;
  D.5806 = D.5805 + lw;
  GC_arrays._words_allocd = D.5806;
  pthread_mutex_unlock (&GC_allocate_ml);
  if (result == 0B) goto <D.5807>; else goto <D.5808>;
  <D.5807>:
  GC_oom_fn.6 = GC_oom_fn;
  D.5780 = GC_oom_fn.6 (lb);
  return D.5780;
  <D.5808>:
  if (init != 0) goto <D.5810>; else goto <D.5811>;
  <D.5810>:
  GC_debugging_started.5 = GC_debugging_started;
  if (GC_debugging_started.5 == 0) goto <D.5812>; else goto <D.5813>;
  <D.5812>:
  D.5797 = n_blocks * 4096;
  memset (result, 0, D.5797);
  <D.5813>:
  <D.5811>:
  D.5780 = result;
  return D.5780;
}


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

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


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

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


GC_incr_words_allocd (size_t n)
{
  long unsigned int D.5819;
  long unsigned int D.5820;

  D.5819 = GC_arrays._words_allocd;
  D.5820 = D.5819 + n;
  GC_arrays._words_allocd = D.5820;
}


GC_incr_mem_freed (size_t n)
{
  long unsigned int D.5821;
  long unsigned int D.5822;

  D.5821 = GC_arrays._mem_freed;
  D.5822 = D.5821 + n;
  GC_arrays._mem_freed = D.5822;
}


GC_generic_malloc_words_small_inner (word lw, int k)
{
  long unsigned int D.5823;
  long unsigned int D.5824;
  char * * D.5825;
  long unsigned int D.5826;
  int GC_is_initialized.7;
  struct hblk * * D.5834;
  int D.5836;
  char * D.5837;
  char * D.5840;
  void * (*<T764>) (size_t) GC_oom_fn.8;
  long unsigned int D.5842;
  char * D.5843;
  long unsigned int D.5844;
  long unsigned int D.5845;
  register char * op;
  register char * * opp;
  register struct obj_kind * kind;

  D.5823 = (long unsigned int) k;
  D.5824 = D.5823 * 32;
  kind = &GC_obj_kinds + D.5824;
  D.5825 = kind->ok_freelist;
  D.5826 = lw * 8;
  opp = D.5825 + D.5826;
  op = *opp;
  if (op == 0B) goto <D.5827>; else goto <D.5828>;
  <D.5827>:
  GC_is_initialized.7 = GC_is_initialized;
  if (GC_is_initialized.7 == 0) goto <D.5830>; else goto <D.5831>;
  <D.5830>:
  GC_init_inner ();
  <D.5831>:
  D.5834 = kind->ok_reclaim_list;
  if (D.5834 != 0B) goto <D.5832>; else goto <D.5835>;
  <D.5835>:
  D.5836 = GC_alloc_reclaim_list (kind);
  if (D.5836 != 0) goto <D.5832>; else goto <D.5833>;
  <D.5832>:
  D.5837 = GC_allocobj (lw, k);
  op = GC_clear_stack (D.5837);
  <D.5833>:
  if (op == 0B) goto <D.5838>; else goto <D.5839>;
  <D.5838>:
  pthread_mutex_unlock (&GC_allocate_ml);
  GC_oom_fn.8 = GC_oom_fn;
  D.5842 = lw << 3;
  D.5840 = GC_oom_fn.8 (D.5842);
  return D.5840;
  <D.5839>:
  <D.5828>:
  D.5843 = MEM[(char * *)op];
  *opp = D.5843;
  MEM[(char * *)op] = 0B;
  D.5844 = GC_arrays._words_allocd;
  D.5845 = D.5844 + lw;
  GC_arrays._words_allocd = D.5845;
  D.5840 = op;
  return D.5840;
}


GC_generic_malloc_words_small (size_t lw, int k)
{
  int GC_have_errors.9;
  int D.5850;
  char * D.5853;
  register char * op;

  GC_have_errors.9 = GC_have_errors;
  if (GC_have_errors.9 != 0) goto <D.5848>; else goto <D.5849>;
  <D.5848>:
  GC_print_all_errors ();
  <D.5849>:
  GC_notify_or_invoke_finalizers ();
  D.5850 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5850 != 0) goto <D.5851>; else goto <D.5852>;
  <D.5851>:
  GC_lock ();
  <D.5852>:
  op = GC_generic_malloc_words_small_inner (lw, k);
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5853 = op;
  return D.5853;
}


GC_generic_malloc_many (word lb, int k, char * * result)
{
  int GC_all_interior_pointers.10;
  long unsigned int D.5856;
  long unsigned int D.5857;
  int D.5862;
  long unsigned int D.5863;
  long unsigned int D.5864;
  int GC_have_errors.11;
  int D.5868;
  int GC_is_initialized.12;
  int GC_incremental.13;
  int GC_dont_gc.14;
  long unsigned int D.5880;
  struct hblk * D.5881;
  long unsigned int GC_gc_no.15;
  short unsigned int D.5883;
  long int D.5886;
  long unsigned int D.5887;
  long unsigned int D.5888;
  long unsigned int my_words_allocd_tmp.16;
  long unsigned int D.5890;
  long unsigned int GC_fl_builder_count.17;
  long unsigned int D.5892;
  int D.5893;
  long unsigned int my_words_allocd.18;
  long unsigned int D.5897;
  int D.5902;
  char * * D.5905;
  long unsigned int my_words_allocd.19;
  char * D.5911;
  long unsigned int D.5912;
  int D.5915;
  struct hdr * D.5918;
  long unsigned int D.5919;
  long unsigned int D.5920;
  long unsigned int D.5921;
  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.10 = GC_all_interior_pointers;
      D.5856 = (long unsigned int) GC_all_interior_pointers.10;
      D.5857 = 2048 - D.5856;
      if (D.5857 < lb) goto <D.5858>; else goto <D.5859>;
      <D.5858>:
      op = GC_generic_malloc (lb, k);
      if (op != 0B) goto <D.5860>; else goto <D.5861>;
      <D.5860>:
      MEM[(char * *)op] = 0B;
      <D.5861>:
      *result = op;
      return;
      <D.5859>:
      GC_all_interior_pointers.10 = GC_all_interior_pointers;
      D.5862 = GC_all_interior_pointers.10 + 7;
      D.5863 = (long unsigned int) D.5862;
      D.5864 = D.5863 + lb;
      lw = D.5864 >> 3;
      GC_have_errors.11 = GC_have_errors;
      if (GC_have_errors.11 != 0) goto <D.5866>; else goto <D.5867>;
      <D.5866>:
      GC_print_all_errors ();
      <D.5867>:
      GC_notify_or_invoke_finalizers ();
      D.5868 = pthread_mutex_trylock (&GC_allocate_ml);
      if (D.5868 != 0) goto <D.5869>; else goto <D.5870>;
      <D.5869>:
      GC_lock ();
      <D.5870>:
      GC_is_initialized.12 = GC_is_initialized;
      if (GC_is_initialized.12 == 0) goto <D.5872>; else goto <D.5873>;
      <D.5872>:
      GC_init_inner ();
      <D.5873>:
      GC_incremental.13 = GC_incremental;
      if (GC_incremental.13 != 0) goto <D.5875>; else goto <D.5876>;
      <D.5875>:
      GC_dont_gc.14 = GC_dont_gc;
      if (GC_dont_gc.14 == 0) goto <D.5878>; else goto <D.5879>;
      <D.5878>:
      GC_collecting = 1;
      GC_collect_a_little_inner (1);
      GC_collecting = 0;
      <D.5879>:
      <D.5876>:
      {
        struct hblk * * rlh;
        struct hblk * hbp;
        struct hdr * hhdr;

        rlh = ok->ok_reclaim_list;
        D.5880 = lw * 8;
        rlh = rlh + D.5880;
        goto <D.5698>;
        <D.5697>:
        hhdr = GC_find_header (hbp);
        D.5881 = hhdr->hb_next;
        *rlh = D.5881;
        GC_gc_no.15 = GC_gc_no;
        D.5883 = (short unsigned int) GC_gc_no.15;
        hhdr->hb_last_reclaimed = D.5883;
        {
          signed_word my_words_allocd_tmp;

          my_words_allocd_tmp = GC_words_allocd_tmp;
          if (my_words_allocd_tmp != 0) goto <D.5884>; else goto <D.5885>;
          <D.5884>:
          D.5886 = -my_words_allocd_tmp;
          D.5887 = (long unsigned int) D.5886;
          GC_atomic_add (&GC_words_allocd_tmp, D.5887);
          D.5888 = GC_arrays._words_allocd;
          my_words_allocd_tmp.16 = (long unsigned int) my_words_allocd_tmp;
          D.5890 = D.5888 + my_words_allocd_tmp.16;
          GC_arrays._words_allocd = D.5890;
          <D.5885>:
        }
        GC_acquire_mark_lock ();
        GC_fl_builder_count.17 = GC_fl_builder_count;
        D.5892 = GC_fl_builder_count.17 + 1;
        GC_fl_builder_count = D.5892;
        pthread_mutex_unlock (&GC_allocate_ml);
        GC_release_mark_lock ();
        D.5893 = ok->ok_init;
        op = GC_reclaim_generic (hbp, hhdr, lw, D.5893, 0, &my_words_allocd);
        if (op != 0B) goto <D.5894>; else goto <D.5895>;
        <D.5894>:
        *result = op;
        my_words_allocd.18 = my_words_allocd;
        GC_atomic_add (&GC_words_allocd_tmp, my_words_allocd.18);
        GC_acquire_mark_lock ();
        GC_fl_builder_count.17 = GC_fl_builder_count;
        D.5897 = GC_fl_builder_count.17 + 18446744073709551615;
        GC_fl_builder_count = D.5897;
        GC_fl_builder_count.17 = GC_fl_builder_count;
        if (GC_fl_builder_count.17 == 0) goto <D.5898>; else goto <D.5899>;
        <D.5898>:
        GC_notify_all_builder ();
        <D.5899>:
        GC_release_mark_lock ();
        GC_clear_stack (0);
        return;
        <D.5895>:
        GC_acquire_mark_lock ();
        GC_fl_builder_count.17 = GC_fl_builder_count;
        D.5897 = GC_fl_builder_count.17 + 18446744073709551615;
        GC_fl_builder_count = D.5897;
        GC_fl_builder_count.17 = GC_fl_builder_count;
        if (GC_fl_builder_count.17 == 0) goto <D.5900>; else goto <D.5901>;
        <D.5900>:
        GC_notify_all_builder ();
        <D.5901>:
        GC_release_mark_lock ();
        D.5902 = pthread_mutex_trylock (&GC_allocate_ml);
        if (D.5902 != 0) goto <D.5903>; else goto <D.5904>;
        <D.5903>:
        GC_lock ();
        <D.5904>:
        <D.5698>:
        hbp = *rlh;
        if (hbp != 0B) goto <D.5697>; else goto <D.5699>;
        <D.5699>:
      }
      D.5905 = GC_obj_kinds[k].ok_freelist;
      D.5880 = lw * 8;
      opp = D.5905 + D.5880;
      op = *opp;
      if (op != 0B) goto <D.5906>; else goto <D.5907>;
      <D.5906>:
      *opp = 0B;
      my_words_allocd = 0;
      p = op;
      goto <D.5702>;
      <D.5701>:
      my_words_allocd.18 = my_words_allocd;
      my_words_allocd.19 = my_words_allocd.18 + lw;
      my_words_allocd = my_words_allocd.19;
      my_words_allocd.18 = my_words_allocd;
      if (my_words_allocd.18 > 511) goto <D.5909>; else goto <D.5910>;
      <D.5909>:
      D.5911 = MEM[(char * *)p];
      *opp = D.5911;
      MEM[(char * *)p] = 0B;
      goto <D.5700>;
      <D.5910>:
      p = MEM[(char * *)p];
      <D.5702>:
      if (p != 0B) goto <D.5701>; else goto <D.5700>;
      <D.5700>:
      D.5888 = GC_arrays._words_allocd;
      my_words_allocd.18 = my_words_allocd;
      D.5912 = D.5888 + my_words_allocd.18;
      GC_arrays._words_allocd = D.5912;
      goto out;
      <D.5907>:
      {
        struct hblk * h;

        h = GC_allochblk (lw, k, 0);
        if (h != 0B) goto <D.5913>; else goto <D.5914>;
        <D.5913>:
        D.5915 = k & -2;
        if (D.5915 == 2) goto <D.5916>; else goto <D.5917>;
        <D.5916>:
        D.5918 = GC_find_header (h);
        GC_set_hdr_marks (D.5918);
        <D.5917>:
        D.5888 = GC_arrays._words_allocd;
        D.5919 = 512 % lw;
        D.5920 = D.5888 - D.5919;
        D.5921 = D.5920 + 512;
        GC_arrays._words_allocd = D.5921;
        GC_acquire_mark_lock ();
        GC_fl_builder_count.17 = GC_fl_builder_count;
        D.5892 = GC_fl_builder_count.17 + 1;
        GC_fl_builder_count = D.5892;
        pthread_mutex_unlock (&GC_allocate_ml);
        GC_release_mark_lock ();
        D.5893 = ok->ok_init;
        op = GC_build_fl (h, lw, D.5893, 0B);
        *result = op;
        GC_acquire_mark_lock ();
        GC_fl_builder_count.17 = GC_fl_builder_count;
        D.5897 = GC_fl_builder_count.17 + 18446744073709551615;
        GC_fl_builder_count = D.5897;
        GC_fl_builder_count.17 = GC_fl_builder_count;
        if (GC_fl_builder_count.17 == 0) goto <D.5922>; else goto <D.5923>;
        <D.5922>:
        GC_notify_all_builder ();
        <D.5923>:
        GC_release_mark_lock ();
        GC_clear_stack (0);
        return;
        <D.5914>:
      }
      op = GC_generic_malloc_inner (lb, k);
      if (op != 0B) goto <D.5924>; else goto <D.5925>;
      <D.5924>:
      MEM[(char * *)op] = 0B;
      <D.5925>:
      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.5929;
  int D.5930;
  GC_word D.5931;
  GC_word old;

  <D.4891>:
  old = *addr;
  D.5929 = old + how_much;
  D.5930 = GC_compare_and_exchange (addr, old, D.5929);
  if (D.5930 == 0) goto <D.4891>; else goto <D.4892>;
  <D.4892>:
  D.5931 = old;
  return D.5931;
}


GC_compare_and_exchange (volatile GC_word * addr, GC_word old, GC_word new_val)
{
  GC_bool D.5933;
  _Bool D.5934;
  int retval;

  __asm__ __volatile__("     csg %1,%2,0(%3)
     ipm %0
     srl %0,28
" : "=&d" retval, "=d" old : "d" new_val, "a" addr, "1" old : "memory", "cc");
  D.5934 = retval == 0;
  D.5933 = (GC_bool) D.5934;
  return D.5933;
}


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

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


GC_malloc_uncollectable (size_t lb)
{
  int GC_all_interior_pointers.20;
  long unsigned int D.5940;
  long unsigned int D.5941;
  unsigned int D.5948;
  int D.5949;
  char * D.5954;
  long unsigned int D.5955;
  long unsigned int D.5956;
  long unsigned int D.5957;
  long unsigned int GC_non_gc_bytes.21;
  long unsigned int D.5959;
  void * D.5960;
  long unsigned int op.22;
  long unsigned int D.5965;
  struct hdr * D.5966;
  int D.5967;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.20 = GC_all_interior_pointers;
  D.5940 = (long unsigned int) GC_all_interior_pointers.20;
  D.5941 = 2048 - D.5940;
  if (D.5941 >= lb) goto <D.5942>; else goto <D.5943>;
  <D.5942>:
  GC_all_interior_pointers.20 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.20 != 0) goto <D.5944>; else goto <D.5945>;
  <D.5944>:
  if (lb != 0) goto <D.5946>; else goto <D.5947>;
  <D.5946>:
  lb = lb + 18446744073709551615;
  <D.5947>:
  <D.5945>:
  D.5948 = GC_arrays._size_map[lb];
  lw = (word) D.5948;
  opp = &GC_arrays._uobjfreelist[lw];
  D.5949 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5949 != 0) goto <D.5950>; else goto <D.5951>;
  <D.5950>:
  GC_lock ();
  <D.5951>:
  op = *opp;
  if (op != 0B) goto <D.5952>; else goto <D.5953>;
  <D.5952>:
  D.5954 = MEM[(char * *)op];
  *opp = D.5954;
  MEM[(char * *)op] = 0B;
  D.5955 = GC_arrays._words_allocd;
  D.5956 = D.5955 + lw;
  GC_arrays._words_allocd = D.5956;
  D.5957 = lw << 3;
  GC_non_gc_bytes.21 = GC_non_gc_bytes;
  D.5959 = D.5957 + GC_non_gc_bytes.21;
  GC_non_gc_bytes = D.5959;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5960 = op;
  return D.5960;
  <D.5953>:
  pthread_mutex_unlock (&GC_allocate_ml);
  op = GC_generic_malloc (lb, 2);
  goto <D.5961>;
  <D.5943>:
  op = GC_generic_malloc (lb, 2);
  <D.5961>:
  if (op == 0B) goto <D.5962>; else goto <D.5963>;
  <D.5962>:
  D.5960 = 0B;
  return D.5960;
  <D.5963>:
  {
    register struct hblk * h;

    op.22 = (long unsigned int) op;
    D.5965 = op.22 & 18446744073709547520;
    h = (struct hblk *) D.5965;
    D.5966 = GC_find_header (h);
    lw = D.5966->hb_sz;
    D.5967 = pthread_mutex_trylock (&GC_allocate_ml);
    if (D.5967 != 0) goto <D.5968>; else goto <D.5969>;
    <D.5968>:
    GC_lock ();
    <D.5969>:
    GC_set_mark_bit (op);
    D.5957 = lw << 3;
    GC_non_gc_bytes.21 = GC_non_gc_bytes;
    D.5959 = D.5957 + GC_non_gc_bytes.21;
    GC_non_gc_bytes = D.5959;
    pthread_mutex_unlock (&GC_allocate_ml);
    D.5960 = op;
    return D.5960;
  }
}


GC_memalign (size_t align, size_t lb)
{
  void * D.5973;
  void * (*<T764>) (size_t) GC_oom_fn.23;
  long unsigned int D.5980;
  long unsigned int D.5981;
  long unsigned int result.24;
  int GC_all_interior_pointers.25;
  size_t new_lb;
  size_t offset;
  char * result;

  if (align <= 8) goto <D.5971>; else goto <D.5972>;
  <D.5971>:
  D.5973 = GC_malloc (lb);
  return D.5973;
  <D.5972>:
  if (align > 2047) goto <D.5974>; else goto <D.5976>;
  <D.5976>:
  if (lb > 2047) goto <D.5974>; else goto <D.5975>;
  <D.5974>:
  if (align > 4096) goto <D.5977>; else goto <D.5978>;
  <D.5977>:
  GC_oom_fn.23 = GC_oom_fn;
  D.5973 = GC_oom_fn.23 (9223372036854774783);
  return D.5973;
  <D.5978>:
  D.5980 = MAX_EXPR <lb, 4096>;
  D.5973 = GC_malloc (D.5980);
  return D.5973;
  <D.5975>:
  D.5981 = lb + align;
  new_lb = D.5981 + 18446744073709551615;
  result = GC_malloc (new_lb);
  result.24 = (long unsigned int) result;
  offset = result.24 % align;
  if (offset != 0) goto <D.5983>; else goto <D.5984>;
  <D.5983>:
  offset = align - offset;
  GC_all_interior_pointers.25 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.25 == 0) goto <D.5986>; else goto <D.5987>;
  <D.5986>:
  if (offset > 2048) goto <D.5988>; else goto <D.5989>;
  <D.5988>:
  D.5973 = GC_malloc (4096);
  return D.5973;
  <D.5989>:
  GC_register_displacement (offset);
  <D.5987>:
  <D.5984>:
  result = result + offset;
  D.5973 = result;
  return D.5973;
}


GC_malloc_atomic_uncollectable (size_t lb)
{
  int GC_all_interior_pointers.26;
  long unsigned int D.5992;
  long unsigned int D.5993;
  unsigned int D.6000;
  int D.6001;
  char * D.6006;
  long unsigned int D.6007;
  long unsigned int D.6008;
  long unsigned int D.6009;
  long unsigned int GC_non_gc_bytes.27;
  long unsigned int D.6011;
  void * D.6012;
  long unsigned int op.28;
  long unsigned int D.6017;
  struct hdr * D.6018;
  int D.6019;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.26 = GC_all_interior_pointers;
  D.5992 = (long unsigned int) GC_all_interior_pointers.26;
  D.5993 = 2048 - D.5992;
  if (D.5993 >= lb) goto <D.5994>; else goto <D.5995>;
  <D.5994>:
  GC_all_interior_pointers.26 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.26 != 0) goto <D.5996>; else goto <D.5997>;
  <D.5996>:
  if (lb != 0) goto <D.5998>; else goto <D.5999>;
  <D.5998>:
  lb = lb + 18446744073709551615;
  <D.5999>:
  <D.5997>:
  D.6000 = GC_arrays._size_map[lb];
  lw = (word) D.6000;
  opp = &GC_arrays._auobjfreelist[lw];
  D.6001 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.6001 != 0) goto <D.6002>; else goto <D.6003>;
  <D.6002>:
  GC_lock ();
  <D.6003>:
  op = *opp;
  if (op != 0B) goto <D.6004>; else goto <D.6005>;
  <D.6004>:
  D.6006 = MEM[(char * *)op];
  *opp = D.6006;
  MEM[(char * *)op] = 0B;
  D.6007 = GC_arrays._words_allocd;
  D.6008 = D.6007 + lw;
  GC_arrays._words_allocd = D.6008;
  D.6009 = lw << 3;
  GC_non_gc_bytes.27 = GC_non_gc_bytes;
  D.6011 = D.6009 + GC_non_gc_bytes.27;
  GC_non_gc_bytes = D.6011;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.6012 = op;
  return D.6012;
  <D.6005>:
  pthread_mutex_unlock (&GC_allocate_ml);
  op = GC_generic_malloc (lb, 3);
  goto <D.6013>;
  <D.5995>:
  op = GC_generic_malloc (lb, 3);
  <D.6013>:
  if (op == 0B) goto <D.6014>; else goto <D.6015>;
  <D.6014>:
  D.6012 = 0B;
  return D.6012;
  <D.6015>:
  {
    register struct hblk * h;

    op.28 = (long unsigned int) op;
    D.6017 = op.28 & 18446744073709547520;
    h = (struct hblk *) D.6017;
    D.6018 = GC_find_header (h);
    lw = D.6018->hb_sz;
    D.6019 = pthread_mutex_trylock (&GC_allocate_ml);
    if (D.6019 != 0) goto <D.6020>; else goto <D.6021>;
    <D.6020>:
    GC_lock ();
    <D.6021>:
    GC_set_mark_bit (op);
    D.6009 = lw << 3;
    GC_non_gc_bytes.27 = GC_non_gc_bytes;
    D.6011 = D.6009 + GC_non_gc_bytes.27;
    GC_non_gc_bytes = D.6011;
    pthread_mutex_unlock (&GC_allocate_ml);
    D.6012 = op;
    return D.6012;
  }
}