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

  switch (knd) <default: <D.6045>, case 0: <D.6041>, case 1: <D.6042>, case 2: <D.6043>, case 3: <D.6044>>
  <D.6041>:
  D.6143 = GC_malloc_atomic (lb);
  return D.6143;
  <D.6042>:
  D.6143 = GC_malloc (lb);
  return D.6143;
  <D.6043>:
  D.6143 = GC_malloc_uncollectable (lb);
  return D.6143;
  <D.6044>:
  D.6143 = GC_malloc_atomic_uncollectable (lb);
  return D.6143;
  <D.6045>:
  D.6143 = GC_generic_malloc (lb, knd);
  return D.6143;
}


GC_realloc (void * p, size_t lb)
{
  void * D.6147;
  long unsigned int p.0;
  long unsigned int D.6149;
  unsigned char D.6150;
  long unsigned int D.6153;
  long unsigned int D.6154;
  int D.6155;
  int D.6158;
  long unsigned int D.6161;
  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.6165;
  long unsigned int D.6166;
  long unsigned int D.6169;
  void * D.6174;
  long unsigned int D.6175;
  register struct hblk * h;
  register struct hdr * hhdr;
  register word sz;
  register word orig_sz;
  int obj_kind;

  if (p == 0B) goto <D.6145>; else goto <D.6146>;
  <D.6145>:
  D.6147 = GC_malloc (lb);
  return D.6147;
  <D.6146>:
  p.0 = (long unsigned int) p;
  D.6149 = p.0 & 18446744073709547520;
  h = (struct hblk *) D.6149;
  hhdr = GC_find_header (h);
  sz = hhdr->hb_sz;
  D.6150 = hhdr->hb_obj_kind;
  obj_kind = (int) D.6150;
  sz = sz << 3;
  orig_sz = sz;
  if (sz > 2048) goto <D.6151>; else goto <D.6152>;
  <D.6151>:
  {
    register word descr;

    D.6153 = sz + 4095;
    sz = D.6153 & 18446744073709547520;
    D.6154 = sz >> 3;
    hhdr->hb_sz = D.6154;
    descr = GC_obj_kinds[obj_kind].ok_descriptor;
    D.6155 = GC_obj_kinds[obj_kind].ok_relocate_descr;
    if (D.6155 != 0) goto <D.6156>; else goto <D.6157>;
    <D.6156>:
    descr = descr + sz;
    <D.6157>:
    hhdr->hb_descr = descr;
    D.6158 = obj_kind & -2;
    if (D.6158 == 2) goto <D.6159>; else goto <D.6160>;
    <D.6159>:
    D.6161 = sz - orig_sz;
    GC_non_gc_bytes.1 = GC_non_gc_bytes;
    GC_non_gc_bytes.2 = D.6161 + GC_non_gc_bytes.1;
    GC_non_gc_bytes = GC_non_gc_bytes.2;
    <D.6160>:
  }
  <D.6152>:
  GC_all_interior_pointers.3 = GC_all_interior_pointers;
  D.6165 = (long unsigned int) GC_all_interior_pointers.3;
  D.6166 = D.6165 + lb;
  if (D.6166 <= sz) goto <D.6167>; else goto <D.6168>;
  <D.6167>:
  D.6169 = sz >> 1;
  if (D.6169 <= lb) goto <D.6170>; else goto <D.6171>;
  <D.6170>:
  if (orig_sz > lb) goto <D.6172>; else goto <D.6173>;
  <D.6172>:
  D.6174 = p + lb;
  D.6175 = orig_sz - lb;
  memset (D.6174, 0, D.6175);
  <D.6173>:
  D.6147 = p;
  return D.6147;
  <D.6171>:
  {
    void * result;

    result = GC_generic_or_special_malloc (lb, obj_kind);
    if (result == 0B) goto <D.6176>; else goto <D.6177>;
    <D.6176>:
    D.6147 = 0B;
    return D.6147;
    <D.6177>:
    memcpy (result, p, lb);
    GC_free (p);
    D.6147 = result;
    return D.6147;
  }
  <D.6168>:
  {
    void * result;

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.6183;
  int D.6188;
  void * D.6190;
  long unsigned int D.6191;

  D.6183 = __builtin_constant_p (__len);
  if (D.6183 != 0) goto <D.6184>; else goto <D.6185>;
  <D.6184>:
  if (__len == 0) goto <D.6186>; else goto <D.6187>;
  <D.6186>:
  D.6188 = __builtin_constant_p (__ch);
  if (D.6188 == 0) goto <D.6181>; else goto <D.6189>;
  <D.6189>:
  if (__ch != 0) goto <D.6181>; else goto <D.6182>;
  <D.6181>:
  __warn_memset_zero_len ();
  D.6190 = __dest;
  return D.6190;
  <D.6182>:
  <D.6187>:
  <D.6185>:
  D.6191 = __builtin_object_size (__dest, 0);
  D.6190 = __builtin___memset_chk (__dest, __ch, __len, D.6191);
  return D.6190;
}


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

  D.6194 = __builtin_object_size (__dest, 0);
  D.6193 = __builtin___memcpy_chk (__dest, __src, __len, D.6194);
  return D.6193;
}


GC_generic_malloc_ignore_off_page (size_t lb, int k)
{
  int GC_all_interior_pointers.4;
  long unsigned int D.6197;
  long unsigned int D.6198;
  char * D.6201;
  int D.6202;
  long unsigned int D.6203;
  long unsigned int D.6204;
  long unsigned int D.6205;
  long unsigned int D.6206;
  int GC_have_errors.5;
  int D.6210;
  int GC_debugging_started.6;
  long unsigned int D.6218;
  word * D.6220;
  long unsigned int D.6221;
  sizetype D.6222;
  word * D.6223;
  sizetype D.6224;
  word * D.6225;
  long unsigned int D.6226;
  long unsigned int D.6227;
  void * (*<T707>) (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.6197 = (long unsigned int) GC_all_interior_pointers.4;
  D.6198 = 2048 - D.6197;
  if (D.6198 >= lb) goto <D.6199>; else goto <D.6200>;
  <D.6199>:
  D.6201 = GC_generic_malloc (lb, k);
  return D.6201;
  <D.6200>:
  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  D.6202 = GC_all_interior_pointers.4 + 7;
  D.6203 = (long unsigned int) D.6202;
  D.6204 = D.6203 + lb;
  lw = D.6204 >> 3;
  D.6205 = lw << 3;
  D.6206 = D.6205 + 4095;
  n_blocks = D.6206 >> 12;
  init = GC_obj_kinds[k].ok_init;
  GC_have_errors.5 = GC_have_errors;
  if (GC_have_errors.5 != 0) goto <D.6208>; else goto <D.6209>;
  <D.6208>:
  GC_print_all_errors ();
  <D.6209>:
  GC_notify_or_invoke_finalizers ();
  D.6210 = GC_test_and_set (&GC_allocate_lock);
  if (D.6210 != 0) goto <D.6211>; else goto <D.6212>;
  <D.6211>:
  GC_lock ();
  <D.6212>:
  result = GC_alloc_large (lw, k, 1);
  if (result != 0B) goto <D.6213>; else goto <D.6214>;
  <D.6213>:
  GC_debugging_started.6 = GC_debugging_started;
  if (GC_debugging_started.6 != 0) goto <D.6216>; else goto <D.6217>;
  <D.6216>:
  D.6218 = n_blocks * 4096;
  memset (result, 0, D.6218);
  goto <D.6219>;
  <D.6217>:
  MEM[(word *)result] = 0;
  D.6220 = result + 8;
  *D.6220 = 0;
  D.6221 = lw * 8;
  D.6222 = D.6221 + 18446744073709551608;
  D.6223 = result + D.6222;
  *D.6223 = 0;
  D.6221 = lw * 8;
  D.6224 = D.6221 + 18446744073709551600;
  D.6225 = result + D.6224;
  *D.6225 = 0;
  <D.6219>:
  <D.6214>:
  D.6226 = GC_arrays._words_allocd;
  D.6227 = D.6226 + lw;
  GC_arrays._words_allocd = D.6227;
  GC_clear (&GC_allocate_lock);
  if (result == 0B) goto <D.6228>; else goto <D.6229>;
  <D.6228>:
  GC_oom_fn.7 = GC_oom_fn;
  D.6201 = GC_oom_fn.7 (lb);
  return D.6201;
  <D.6229>:
  if (init != 0) goto <D.6231>; else goto <D.6232>;
  <D.6231>:
  GC_debugging_started.6 = GC_debugging_started;
  if (GC_debugging_started.6 == 0) goto <D.6233>; else goto <D.6234>;
  <D.6233>:
  D.6218 = n_blocks * 4096;
  memset (result, 0, D.6218);
  <D.6234>:
  <D.6232>:
  D.6201 = result;
  return D.6201;
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.6236;
  int oldval;
  int temp;

  temp = 1;
  __asm__ __volatile__("1:	lwarx %0,0,%1
	cmpwi %0, 0
	bne 2f
	stwcx. %2,0,%1
	bne- 1b
	sync
2:	
" : "=&r" oldval : "r" addr, "r" temp : "memory", "cr0");
  D.6236 = oldval;
  return D.6236;
}


GC_clear (volatile unsigned int * addr)
{
  __asm__ __volatile__("lwsync" :  :  : "memory");
  *addr = 0;
}


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

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


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

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


GC_incr_words_allocd (size_t n)
{
  long unsigned int D.6242;
  long unsigned int D.6243;

  D.6242 = GC_arrays._words_allocd;
  D.6243 = D.6242 + n;
  GC_arrays._words_allocd = D.6243;
}


GC_incr_mem_freed (size_t n)
{
  long unsigned int D.6244;
  long unsigned int D.6245;

  D.6244 = GC_arrays._mem_freed;
  D.6245 = D.6244 + n;
  GC_arrays._mem_freed = D.6245;
}


GC_generic_malloc_words_small_inner (word lw, int k)
{
  long unsigned int D.6246;
  long unsigned int D.6247;
  char * * D.6248;
  long unsigned int D.6249;
  int GC_is_initialized.8;
  struct hblk * * D.6257;
  int D.6259;
  char * D.6260;
  char * D.6263;
  void * (*<T707>) (size_t) GC_oom_fn.9;
  long unsigned int D.6265;
  char * D.6266;
  long unsigned int D.6267;
  long unsigned int D.6268;
  register char * op;
  register char * * opp;
  register struct obj_kind * kind;

  D.6246 = (long unsigned int) k;
  D.6247 = D.6246 * 32;
  kind = &GC_obj_kinds + D.6247;
  D.6248 = kind->ok_freelist;
  D.6249 = lw * 8;
  opp = D.6248 + D.6249;
  op = *opp;
  if (op == 0B) goto <D.6250>; else goto <D.6251>;
  <D.6250>:
  GC_is_initialized.8 = GC_is_initialized;
  if (GC_is_initialized.8 == 0) goto <D.6253>; else goto <D.6254>;
  <D.6253>:
  GC_init_inner ();
  <D.6254>:
  D.6257 = kind->ok_reclaim_list;
  if (D.6257 != 0B) goto <D.6255>; else goto <D.6258>;
  <D.6258>:
  D.6259 = GC_alloc_reclaim_list (kind);
  if (D.6259 != 0) goto <D.6255>; else goto <D.6256>;
  <D.6255>:
  D.6260 = GC_allocobj (lw, k);
  op = GC_clear_stack (D.6260);
  <D.6256>:
  if (op == 0B) goto <D.6261>; else goto <D.6262>;
  <D.6261>:
  GC_clear (&GC_allocate_lock);
  GC_oom_fn.9 = GC_oom_fn;
  D.6265 = lw << 3;
  D.6263 = GC_oom_fn.9 (D.6265);
  return D.6263;
  <D.6262>:
  <D.6251>:
  D.6266 = MEM[(char * *)op];
  *opp = D.6266;
  MEM[(char * *)op] = 0B;
  D.6267 = GC_arrays._words_allocd;
  D.6268 = D.6267 + lw;
  GC_arrays._words_allocd = D.6268;
  D.6263 = op;
  return D.6263;
}


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

  GC_have_errors.10 = GC_have_errors;
  if (GC_have_errors.10 != 0) goto <D.6271>; else goto <D.6272>;
  <D.6271>:
  GC_print_all_errors ();
  <D.6272>:
  GC_notify_or_invoke_finalizers ();
  D.6273 = GC_test_and_set (&GC_allocate_lock);
  if (D.6273 != 0) goto <D.6274>; else goto <D.6275>;
  <D.6274>:
  GC_lock ();
  <D.6275>:
  op = GC_generic_malloc_words_small_inner (lw, k);
  GC_clear (&GC_allocate_lock);
  D.6276 = op;
  return D.6276;
}


GC_generic_malloc_many (word lb, int k, char * * result)
{
  int GC_all_interior_pointers.11;
  long unsigned int D.6279;
  long unsigned int D.6280;
  int D.6285;
  long unsigned int D.6286;
  long unsigned int D.6287;
  int GC_have_errors.12;
  int D.6291;
  int GC_is_initialized.13;
  int GC_incremental.14;
  int GC_dont_gc.15;
  long unsigned int D.6303;
  struct hblk * D.6304;
  long unsigned int GC_gc_no.16;
  short unsigned int D.6306;
  int D.6307;
  long unsigned int D.6310;
  long unsigned int D.6311;
  char * * D.6312;
  char * D.6317;
  int D.6320;
  struct hdr * D.6323;
  long unsigned int D.6324;
  long unsigned int D.6325;
  long unsigned int D.6326;
  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.11 = GC_all_interior_pointers;
  D.6279 = (long unsigned int) GC_all_interior_pointers.11;
  D.6280 = 2048 - D.6279;
  if (D.6280 < lb) goto <D.6281>; else goto <D.6282>;
  <D.6281>:
  op = GC_generic_malloc (lb, k);
  if (op != 0B) goto <D.6283>; else goto <D.6284>;
  <D.6283>:
  MEM[(char * *)op] = 0B;
  <D.6284>:
  *result = op;
  return;
  <D.6282>:
  GC_all_interior_pointers.11 = GC_all_interior_pointers;
  D.6285 = GC_all_interior_pointers.11 + 7;
  D.6286 = (long unsigned int) D.6285;
  D.6287 = D.6286 + lb;
  lw = D.6287 >> 3;
  GC_have_errors.12 = GC_have_errors;
  if (GC_have_errors.12 != 0) goto <D.6289>; else goto <D.6290>;
  <D.6289>:
  GC_print_all_errors ();
  <D.6290>:
  GC_notify_or_invoke_finalizers ();
  D.6291 = GC_test_and_set (&GC_allocate_lock);
  if (D.6291 != 0) goto <D.6292>; else goto <D.6293>;
  <D.6292>:
  GC_lock ();
  <D.6293>:
  GC_is_initialized.13 = GC_is_initialized;
  if (GC_is_initialized.13 == 0) goto <D.6295>; else goto <D.6296>;
  <D.6295>:
  GC_init_inner ();
  <D.6296>:
  GC_incremental.14 = GC_incremental;
  if (GC_incremental.14 != 0) goto <D.6298>; else goto <D.6299>;
  <D.6298>:
  GC_dont_gc.15 = GC_dont_gc;
  if (GC_dont_gc.15 == 0) goto <D.6301>; else goto <D.6302>;
  <D.6301>:
  GC_collecting = 1;
  GC_collect_a_little_inner (1);
  GC_collecting = 0;
  <D.6302>:
  <D.6299>:
  {
    struct hblk * * rlh;
    struct hblk * hbp;
    struct hdr * hhdr;

    rlh = ok->ok_reclaim_list;
    D.6303 = lw * 8;
    rlh = rlh + D.6303;
    goto <D.6111>;
    <D.6110>:
    hhdr = GC_find_header (hbp);
    D.6304 = hhdr->hb_next;
    *rlh = D.6304;
    GC_gc_no.16 = GC_gc_no;
    D.6306 = (short unsigned int) GC_gc_no.16;
    hhdr->hb_last_reclaimed = D.6306;
    D.6307 = ok->ok_init;
    op = GC_reclaim_generic (hbp, hhdr, lw, D.6307, 0);
    if (op != 0B) goto <D.6308>; else goto <D.6309>;
    <D.6308>:
    p = op;
    goto <D.6107>;
    <D.6106>:
    my_words_allocd = my_words_allocd + lw;
    p = MEM[(char * *)p];
    <D.6107>:
    if (p != 0B) goto <D.6106>; else goto <D.6108>;
    <D.6108>:
    D.6310 = GC_arrays._words_allocd;
    D.6311 = D.6310 + my_words_allocd;
    GC_arrays._words_allocd = D.6311;
    goto out;
    <D.6309>:
    <D.6111>:
    hbp = *rlh;
    if (hbp != 0B) goto <D.6110>; else goto <D.6112>;
    <D.6112>:
  }
  D.6312 = GC_obj_kinds[k].ok_freelist;
  D.6303 = lw * 8;
  opp = D.6312 + D.6303;
  op = *opp;
  if (op != 0B) goto <D.6313>; else goto <D.6314>;
  <D.6313>:
  *opp = 0B;
  my_words_allocd = 0;
  p = op;
  goto <D.6115>;
  <D.6114>:
  my_words_allocd = my_words_allocd + lw;
  if (my_words_allocd > 511) goto <D.6315>; else goto <D.6316>;
  <D.6315>:
  D.6317 = MEM[(char * *)p];
  *opp = D.6317;
  MEM[(char * *)p] = 0B;
  goto <D.6113>;
  <D.6316>:
  p = MEM[(char * *)p];
  <D.6115>:
  if (p != 0B) goto <D.6114>; else goto <D.6113>;
  <D.6113>:
  D.6310 = GC_arrays._words_allocd;
  D.6311 = D.6310 + my_words_allocd;
  GC_arrays._words_allocd = D.6311;
  goto out;
  <D.6314>:
  {
    struct hblk * h;

    h = GC_allochblk (lw, k, 0);
    if (h != 0B) goto <D.6318>; else goto <D.6319>;
    <D.6318>:
    D.6320 = k & -2;
    if (D.6320 == 2) goto <D.6321>; else goto <D.6322>;
    <D.6321>:
    D.6323 = GC_find_header (h);
    GC_set_hdr_marks (D.6323);
    <D.6322>:
    D.6310 = GC_arrays._words_allocd;
    D.6324 = 512 % lw;
    D.6325 = D.6310 - D.6324;
    D.6326 = D.6325 + 512;
    GC_arrays._words_allocd = D.6326;
    D.6307 = ok->ok_init;
    op = GC_build_fl (h, lw, D.6307, 0B);
    goto out;
    <D.6319>:
  }
  op = GC_generic_malloc_inner (lb, k);
  if (op != 0B) goto <D.6327>; else goto <D.6328>;
  <D.6327>:
  MEM[(char * *)op] = 0B;
  <D.6328>:
  out:
  *result = op;
  GC_clear (&GC_allocate_lock);
  GC_clear_stack (0);
}


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

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


GC_malloc_uncollectable (size_t lb)
{
  int GC_all_interior_pointers.17;
  long unsigned int D.6334;
  long unsigned int D.6335;
  unsigned int D.6342;
  int D.6343;
  char * D.6348;
  long unsigned int D.6349;
  long unsigned int D.6350;
  long unsigned int D.6351;
  long unsigned int GC_non_gc_bytes.18;
  long unsigned int GC_non_gc_bytes.19;
  void * D.6354;
  long unsigned int op.20;
  long unsigned int D.6359;
  struct hdr * D.6360;
  int D.6361;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.17 = GC_all_interior_pointers;
  D.6334 = (long unsigned int) GC_all_interior_pointers.17;
  D.6335 = 2048 - D.6334;
  if (D.6335 >= lb) goto <D.6336>; else goto <D.6337>;
  <D.6336>:
  GC_all_interior_pointers.17 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.17 != 0) goto <D.6338>; else goto <D.6339>;
  <D.6338>:
  if (lb != 0) goto <D.6340>; else goto <D.6341>;
  <D.6340>:
  lb = lb + 18446744073709551615;
  <D.6341>:
  <D.6339>:
  D.6342 = GC_arrays._size_map[lb];
  lw = (word) D.6342;
  opp = &GC_arrays._uobjfreelist[lw];
  D.6343 = GC_test_and_set (&GC_allocate_lock);
  if (D.6343 != 0) goto <D.6344>; else goto <D.6345>;
  <D.6344>:
  GC_lock ();
  <D.6345>:
  op = *opp;
  if (op != 0B) goto <D.6346>; else goto <D.6347>;
  <D.6346>:
  D.6348 = MEM[(char * *)op];
  *opp = D.6348;
  MEM[(char * *)op] = 0B;
  D.6349 = GC_arrays._words_allocd;
  D.6350 = D.6349 + lw;
  GC_arrays._words_allocd = D.6350;
  D.6351 = lw << 3;
  GC_non_gc_bytes.18 = GC_non_gc_bytes;
  GC_non_gc_bytes.19 = D.6351 + GC_non_gc_bytes.18;
  GC_non_gc_bytes = GC_non_gc_bytes.19;
  GC_clear (&GC_allocate_lock);
  D.6354 = op;
  return D.6354;
  <D.6347>:
  GC_clear (&GC_allocate_lock);
  op = GC_generic_malloc (lb, 2);
  goto <D.6355>;
  <D.6337>:
  op = GC_generic_malloc (lb, 2);
  <D.6355>:
  if (op == 0B) goto <D.6356>; else goto <D.6357>;
  <D.6356>:
  D.6354 = 0B;
  return D.6354;
  <D.6357>:
  {
    register struct hblk * h;

    op.20 = (long unsigned int) op;
    D.6359 = op.20 & 18446744073709547520;
    h = (struct hblk *) D.6359;
    D.6360 = GC_find_header (h);
    lw = D.6360->hb_sz;
    D.6361 = GC_test_and_set (&GC_allocate_lock);
    if (D.6361 != 0) goto <D.6362>; else goto <D.6363>;
    <D.6362>:
    GC_lock ();
    <D.6363>:
    GC_set_mark_bit (op);
    D.6351 = lw << 3;
    GC_non_gc_bytes.18 = GC_non_gc_bytes;
    GC_non_gc_bytes.19 = D.6351 + GC_non_gc_bytes.18;
    GC_non_gc_bytes = GC_non_gc_bytes.19;
    GC_clear (&GC_allocate_lock);
    D.6354 = op;
    return D.6354;
  }
}


GC_memalign (size_t align, size_t lb)
{
  void * D.6367;
  void * (*<T707>) (size_t) GC_oom_fn.21;
  long unsigned int D.6374;
  long unsigned int D.6375;
  long unsigned int result.22;
  int GC_all_interior_pointers.23;
  size_t new_lb;
  size_t offset;
  char * result;

  if (align <= 8) goto <D.6365>; else goto <D.6366>;
  <D.6365>:
  D.6367 = GC_malloc (lb);
  return D.6367;
  <D.6366>:
  if (align > 2047) goto <D.6368>; else goto <D.6370>;
  <D.6370>:
  if (lb > 2047) goto <D.6368>; else goto <D.6369>;
  <D.6368>:
  if (align > 4096) goto <D.6371>; else goto <D.6372>;
  <D.6371>:
  GC_oom_fn.21 = GC_oom_fn;
  D.6367 = GC_oom_fn.21 (9223372036854774783);
  return D.6367;
  <D.6372>:
  D.6374 = MAX_EXPR <lb, 4096>;
  D.6367 = GC_malloc (D.6374);
  return D.6367;
  <D.6369>:
  D.6375 = lb + align;
  new_lb = D.6375 + 18446744073709551615;
  result = GC_malloc (new_lb);
  result.22 = (long unsigned int) result;
  offset = result.22 % align;
  if (offset != 0) goto <D.6377>; else goto <D.6378>;
  <D.6377>:
  offset = align - offset;
  GC_all_interior_pointers.23 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.23 == 0) goto <D.6380>; else goto <D.6381>;
  <D.6380>:
  if (offset > 2048) goto <D.6382>; else goto <D.6383>;
  <D.6382>:
  D.6367 = GC_malloc (4096);
  return D.6367;
  <D.6383>:
  GC_register_displacement (offset);
  <D.6381>:
  <D.6378>:
  result = result + offset;
  D.6367 = result;
  return D.6367;
}


GC_malloc_atomic_uncollectable (size_t lb)
{
  int GC_all_interior_pointers.24;
  long unsigned int D.6386;
  long unsigned int D.6387;
  unsigned int D.6394;
  int D.6395;
  char * D.6400;
  long unsigned int D.6401;
  long unsigned int D.6402;
  long unsigned int D.6403;
  long unsigned int GC_non_gc_bytes.25;
  long unsigned int GC_non_gc_bytes.26;
  void * D.6406;
  long unsigned int op.27;
  long unsigned int D.6411;
  struct hdr * D.6412;
  int D.6413;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.24 = GC_all_interior_pointers;
  D.6386 = (long unsigned int) GC_all_interior_pointers.24;
  D.6387 = 2048 - D.6386;
  if (D.6387 >= lb) goto <D.6388>; else goto <D.6389>;
  <D.6388>:
  GC_all_interior_pointers.24 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.24 != 0) goto <D.6390>; else goto <D.6391>;
  <D.6390>:
  if (lb != 0) goto <D.6392>; else goto <D.6393>;
  <D.6392>:
  lb = lb + 18446744073709551615;
  <D.6393>:
  <D.6391>:
  D.6394 = GC_arrays._size_map[lb];
  lw = (word) D.6394;
  opp = &GC_arrays._auobjfreelist[lw];
  D.6395 = GC_test_and_set (&GC_allocate_lock);
  if (D.6395 != 0) goto <D.6396>; else goto <D.6397>;
  <D.6396>:
  GC_lock ();
  <D.6397>:
  op = *opp;
  if (op != 0B) goto <D.6398>; else goto <D.6399>;
  <D.6398>:
  D.6400 = MEM[(char * *)op];
  *opp = D.6400;
  MEM[(char * *)op] = 0B;
  D.6401 = GC_arrays._words_allocd;
  D.6402 = D.6401 + lw;
  GC_arrays._words_allocd = D.6402;
  D.6403 = lw << 3;
  GC_non_gc_bytes.25 = GC_non_gc_bytes;
  GC_non_gc_bytes.26 = D.6403 + GC_non_gc_bytes.25;
  GC_non_gc_bytes = GC_non_gc_bytes.26;
  GC_clear (&GC_allocate_lock);
  D.6406 = op;
  return D.6406;
  <D.6399>:
  GC_clear (&GC_allocate_lock);
  op = GC_generic_malloc (lb, 3);
  goto <D.6407>;
  <D.6389>:
  op = GC_generic_malloc (lb, 3);
  <D.6407>:
  if (op == 0B) goto <D.6408>; else goto <D.6409>;
  <D.6408>:
  D.6406 = 0B;
  return D.6406;
  <D.6409>:
  {
    register struct hblk * h;

    op.27 = (long unsigned int) op;
    D.6411 = op.27 & 18446744073709547520;
    h = (struct hblk *) D.6411;
    D.6412 = GC_find_header (h);
    lw = D.6412->hb_sz;
    D.6413 = GC_test_and_set (&GC_allocate_lock);
    if (D.6413 != 0) goto <D.6414>; else goto <D.6415>;
    <D.6414>:
    GC_lock ();
    <D.6415>:
    GC_set_mark_bit (op);
    D.6403 = lw << 3;
    GC_non_gc_bytes.25 = GC_non_gc_bytes;
    GC_non_gc_bytes.26 = D.6403 + GC_non_gc_bytes.25;
    GC_non_gc_bytes = GC_non_gc_bytes.26;
    GC_clear (&GC_allocate_lock);
    D.6406 = op;
    return D.6406;
  }
}