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

  switch (knd) <default: <D.5138>, case 0: <D.5134>, case 1: <D.5135>, case 2: <D.5136>, case 3: <D.5137>>
  <D.5134>:
  D.5236 = GC_malloc_atomic (lb);
  return D.5236;
  <D.5135>:
  D.5236 = GC_malloc (lb);
  return D.5236;
  <D.5136>:
  D.5236 = GC_malloc_uncollectable (lb);
  return D.5236;
  <D.5137>:
  D.5236 = GC_malloc_atomic_uncollectable (lb);
  return D.5236;
  <D.5138>:
  D.5236 = GC_generic_malloc (lb, knd);
  return D.5236;
}


GC_realloc (void * p, size_t lb)
{
  void * D.5240;
  long unsigned int p.0;
  long unsigned int D.5242;
  long unsigned int h.1;
  long unsigned int D.5244;
  struct bottom_index * D.5245;
  long unsigned int D.5246;
  long unsigned int D.5247;
  unsigned char D.5248;
  long unsigned int D.5251;
  long unsigned int D.5252;
  int D.5253;
  int D.5256;
  long unsigned int D.5259;
  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.5264;
  long unsigned int D.5267;
  void * D.5272;
  long unsigned int D.5273;
  register struct hblk * h;
  register struct hdr * hhdr;
  register word sz;
  register word orig_sz;
  int obj_kind;

  if (p == 0B) goto <D.5238>; else goto <D.5239>;
  <D.5238>:
  D.5240 = GC_malloc (lb);
  return D.5240;
  <D.5239>:
  p.0 = (long unsigned int) p;
  D.5242 = p.0 & 4294963200;
  h = (struct hblk *) D.5242;
  h.1 = (long unsigned int) h;
  D.5244 = h.1 >> 22;
  D.5245 = GC_arrays._top_index[D.5244];
  h.1 = (long unsigned int) h;
  D.5246 = h.1 >> 12;
  D.5247 = D.5246 & 1023;
  hhdr = D.5245->index[D.5247];
  sz = hhdr->hb_sz;
  D.5248 = hhdr->hb_obj_kind;
  obj_kind = (int) D.5248;
  sz = sz << 2;
  orig_sz = sz;
  if (sz > 2048) goto <D.5249>; else goto <D.5250>;
  <D.5249>:
  {
    register word descr;

    D.5251 = sz + 4095;
    sz = D.5251 & 4294963200;
    D.5252 = sz >> 2;
    hhdr->hb_sz = D.5252;
    descr = GC_obj_kinds[obj_kind].ok_descriptor;
    D.5253 = GC_obj_kinds[obj_kind].ok_relocate_descr;
    if (D.5253 != 0) goto <D.5254>; else goto <D.5255>;
    <D.5254>:
    descr = descr + sz;
    <D.5255>:
    hhdr->hb_descr = descr;
    D.5256 = obj_kind & -2;
    if (D.5256 == 2) goto <D.5257>; else goto <D.5258>;
    <D.5257>:
    D.5259 = sz - orig_sz;
    GC_non_gc_bytes.2 = GC_non_gc_bytes;
    GC_non_gc_bytes.3 = D.5259 + GC_non_gc_bytes.2;
    GC_non_gc_bytes = GC_non_gc_bytes.3;
    <D.5258>:
  }
  <D.5250>:
  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  GC_all_interior_pointers.5 = (unsigned int) GC_all_interior_pointers.4;
  D.5264 = lb + GC_all_interior_pointers.5;
  if (D.5264 <= sz) goto <D.5265>; else goto <D.5266>;
  <D.5265>:
  D.5267 = sz >> 1;
  if (D.5267 <= lb) goto <D.5268>; else goto <D.5269>;
  <D.5268>:
  if (orig_sz > lb) goto <D.5270>; else goto <D.5271>;
  <D.5270>:
  D.5272 = p + lb;
  D.5273 = orig_sz - lb;
  memset (D.5272, 0, D.5273);
  <D.5271>:
  D.5240 = p;
  return D.5240;
  <D.5269>:
  {
    void * result;

    result = GC_generic_or_special_malloc (lb, obj_kind);
    if (result == 0B) goto <D.5274>; else goto <D.5275>;
    <D.5274>:
    D.5240 = 0B;
    return D.5240;
    <D.5275>:
    memcpy (result, p, lb);
    GC_free (p);
    D.5240 = result;
    return D.5240;
  }
  <D.5266>:
  {
    void * result;

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.5281;
  int D.5286;
  void * D.5288;
  unsigned int D.5289;

  D.5281 = __builtin_constant_p (__len);
  if (D.5281 != 0) goto <D.5282>; else goto <D.5283>;
  <D.5282>:
  if (__len == 0) goto <D.5284>; else goto <D.5285>;
  <D.5284>:
  D.5286 = __builtin_constant_p (__ch);
  if (D.5286 == 0) goto <D.5279>; else goto <D.5287>;
  <D.5287>:
  if (__ch != 0) goto <D.5279>; else goto <D.5280>;
  <D.5279>:
  __warn_memset_zero_len ();
  D.5288 = __dest;
  return D.5288;
  <D.5280>:
  <D.5285>:
  <D.5283>:
  D.5289 = __builtin_object_size (__dest, 0);
  D.5288 = __builtin___memset_chk (__dest, __ch, __len, D.5289);
  return D.5288;
}


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

  D.5292 = __builtin_object_size (__dest, 0);
  D.5291 = __builtin___memcpy_chk (__dest, __src, __len, D.5292);
  return D.5291;
}


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.5296;
  char * D.5299;
  unsigned int GC_all_interior_pointers.8;
  unsigned int D.5301;
  unsigned int D.5302;
  long unsigned int D.5303;
  long unsigned int D.5304;
  int GC_have_errors.9;
  int D.5308;
  int GC_debugging_started.10;
  long unsigned int D.5316;
  word * D.5318;
  sizetype D.5319;
  sizetype D.5320;
  word * D.5321;
  sizetype D.5322;
  sizetype D.5323;
  word * D.5324;
  long unsigned int D.5325;
  long unsigned int D.5326;
  void * (*<T623>) (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.5296 = 2048 - GC_all_interior_pointers.7;
  if (D.5296 >= lb) goto <D.5297>; else goto <D.5298>;
  <D.5297>:
  D.5299 = GC_generic_malloc (lb, k);
  return D.5299;
  <D.5298>:
  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  GC_all_interior_pointers.8 = (unsigned int) GC_all_interior_pointers.6;
  D.5301 = GC_all_interior_pointers.8 + lb;
  D.5302 = D.5301 + 3;
  lw = D.5302 >> 2;
  D.5303 = lw << 2;
  D.5304 = D.5303 + 4095;
  n_blocks = D.5304 >> 12;
  init = GC_obj_kinds[k].ok_init;
  GC_have_errors.9 = GC_have_errors;
  if (GC_have_errors.9 != 0) goto <D.5306>; else goto <D.5307>;
  <D.5306>:
  GC_print_all_errors ();
  <D.5307>:
  GC_notify_or_invoke_finalizers ();
  D.5308 = _test_and_set (&GC_allocate_lock, 1);
  if (D.5308 != 0) goto <D.5309>; else goto <D.5310>;
  <D.5309>:
  GC_lock ();
  <D.5310>:
  result = GC_alloc_large (lw, k, 1);
  if (result != 0B) goto <D.5311>; else goto <D.5312>;
  <D.5311>:
  GC_debugging_started.10 = GC_debugging_started;
  if (GC_debugging_started.10 != 0) goto <D.5314>; else goto <D.5315>;
  <D.5314>:
  D.5316 = n_blocks * 4096;
  memset (result, 0, D.5316);
  goto <D.5317>;
  <D.5315>:
  MEM[(word *)result] = 0;
  D.5318 = result + 4;
  *D.5318 = 0;
  D.5319 = lw + 1073741823;
  D.5320 = D.5319 * 4;
  D.5321 = result + D.5320;
  *D.5321 = 0;
  D.5322 = lw + 1073741822;
  D.5323 = D.5322 * 4;
  D.5324 = result + D.5323;
  *D.5324 = 0;
  <D.5317>:
  <D.5312>:
  D.5325 = GC_arrays._words_allocd;
  D.5326 = D.5325 + lw;
  GC_arrays._words_allocd = D.5326;
  GC_clear (&GC_allocate_lock);
  if (result == 0B) goto <D.5327>; else goto <D.5328>;
  <D.5327>:
  GC_oom_fn.11 = GC_oom_fn;
  D.5299 = GC_oom_fn.11 (lb);
  return D.5299;
  <D.5328>:
  if (init != 0) goto <D.5330>; else goto <D.5331>;
  <D.5330>:
  GC_debugging_started.10 = GC_debugging_started;
  if (GC_debugging_started.10 == 0) goto <D.5332>; else goto <D.5333>;
  <D.5332>:
  D.5316 = n_blocks * 4096;
  memset (result, 0, D.5316);
  <D.5333>:
  <D.5331>:
  D.5299 = result;
  return D.5299;
}


_test_and_set (int * __p, int __v)
{
  int D.5335;
  int __r;
  int __t;

  __asm__ __volatile__("/* Inline test and set */
.set	push
	.set	mips2
	sync
	1:
	ll	%0,%3
	move	%1,%4
	beq	%0,%4,2f
	sc	%1,%2
	beqz	%1,1b
sync
	.set	pop
	2:
	/* End test and set */" : "=&r" __r, "=&r" __t, "=m" *__p : "m" *__p, "r" __v : "memory");
  D.5335 = __r;
  return D.5335;
}


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


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

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


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

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


GC_incr_words_allocd (size_t n)
{
  long unsigned int D.5341;
  long unsigned int D.5342;

  D.5341 = GC_arrays._words_allocd;
  D.5342 = D.5341 + n;
  GC_arrays._words_allocd = D.5342;
}


GC_incr_mem_freed (size_t n)
{
  long unsigned int D.5343;
  long unsigned int D.5344;

  D.5343 = GC_arrays._mem_freed;
  D.5344 = D.5343 + n;
  GC_arrays._mem_freed = D.5344;
}


GC_generic_malloc_words_small_inner (word lw, int k)
{
  unsigned int k.12;
  unsigned int D.5346;
  char * * D.5347;
  long unsigned int D.5348;
  int GC_is_initialized.13;
  struct hblk * * D.5356;
  int D.5358;
  char * D.5359;
  char * D.5362;
  void * (*<T623>) (size_t) GC_oom_fn.14;
  long unsigned int D.5364;
  char * D.5365;
  long unsigned int D.5366;
  long unsigned int D.5367;
  register char * op;
  register char * * opp;
  register struct obj_kind * kind;

  k.12 = (unsigned int) k;
  D.5346 = k.12 * 20;
  kind = &GC_obj_kinds + D.5346;
  D.5347 = kind->ok_freelist;
  D.5348 = lw * 4;
  opp = D.5347 + D.5348;
  op = *opp;
  if (op == 0B) goto <D.5349>; else goto <D.5350>;
  <D.5349>:
  GC_is_initialized.13 = GC_is_initialized;
  if (GC_is_initialized.13 == 0) goto <D.5352>; else goto <D.5353>;
  <D.5352>:
  GC_init_inner ();
  <D.5353>:
  D.5356 = kind->ok_reclaim_list;
  if (D.5356 != 0B) goto <D.5354>; else goto <D.5357>;
  <D.5357>:
  D.5358 = GC_alloc_reclaim_list (kind);
  if (D.5358 != 0) goto <D.5354>; else goto <D.5355>;
  <D.5354>:
  D.5359 = GC_allocobj (lw, k);
  op = GC_clear_stack (D.5359);
  <D.5355>:
  if (op == 0B) goto <D.5360>; else goto <D.5361>;
  <D.5360>:
  GC_clear (&GC_allocate_lock);
  GC_oom_fn.14 = GC_oom_fn;
  D.5364 = lw << 2;
  D.5362 = GC_oom_fn.14 (D.5364);
  return D.5362;
  <D.5361>:
  <D.5350>:
  D.5365 = MEM[(char * *)op];
  *opp = D.5365;
  MEM[(char * *)op] = 0B;
  D.5366 = GC_arrays._words_allocd;
  D.5367 = D.5366 + lw;
  GC_arrays._words_allocd = D.5367;
  D.5362 = op;
  return D.5362;
}


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

  GC_have_errors.15 = GC_have_errors;
  if (GC_have_errors.15 != 0) goto <D.5370>; else goto <D.5371>;
  <D.5370>:
  GC_print_all_errors ();
  <D.5371>:
  GC_notify_or_invoke_finalizers ();
  D.5372 = _test_and_set (&GC_allocate_lock, 1);
  if (D.5372 != 0) goto <D.5373>; else goto <D.5374>;
  <D.5373>:
  GC_lock ();
  <D.5374>:
  op = GC_generic_malloc_words_small_inner (lw, k);
  GC_clear (&GC_allocate_lock);
  D.5375 = op;
  return D.5375;
}


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.5379;
  long unsigned int D.5384;
  long unsigned int D.5385;
  long unsigned int D.5386;
  int GC_have_errors.18;
  int D.5390;
  int GC_is_initialized.19;
  int GC_incremental.20;
  int GC_dont_gc.21;
  long unsigned int D.5402;
  long unsigned int hbp.22;
  long unsigned int D.5404;
  struct bottom_index * D.5405;
  long unsigned int D.5406;
  long unsigned int D.5407;
  struct hblk * D.5408;
  long unsigned int GC_gc_no.23;
  short unsigned int D.5410;
  int D.5411;
  long unsigned int D.5414;
  long unsigned int D.5415;
  char * * D.5416;
  char * D.5421;
  int D.5424;
  long unsigned int h.24;
  long unsigned int D.5428;
  struct bottom_index * D.5429;
  long unsigned int D.5430;
  long unsigned int D.5431;
  struct hdr * D.5432;
  long unsigned int D.5433;
  long unsigned int D.5434;
  long unsigned int D.5435;
  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.5379 = 2048 - GC_all_interior_pointers.17;
  if (D.5379 < lb) goto <D.5380>; else goto <D.5381>;
  <D.5380>:
  op = GC_generic_malloc (lb, k);
  if (op != 0B) goto <D.5382>; else goto <D.5383>;
  <D.5382>:
  MEM[(char * *)op] = 0B;
  <D.5383>:
  *result = op;
  return;
  <D.5381>:
  GC_all_interior_pointers.16 = GC_all_interior_pointers;
  GC_all_interior_pointers.17 = (long unsigned int) GC_all_interior_pointers.16;
  D.5384 = lb + GC_all_interior_pointers.17;
  D.5385 = D.5384 + 7;
  D.5386 = D.5385 >> 2;
  lw = D.5386 & 4294967294;
  GC_have_errors.18 = GC_have_errors;
  if (GC_have_errors.18 != 0) goto <D.5388>; else goto <D.5389>;
  <D.5388>:
  GC_print_all_errors ();
  <D.5389>:
  GC_notify_or_invoke_finalizers ();
  D.5390 = _test_and_set (&GC_allocate_lock, 1);
  if (D.5390 != 0) goto <D.5391>; else goto <D.5392>;
  <D.5391>:
  GC_lock ();
  <D.5392>:
  GC_is_initialized.19 = GC_is_initialized;
  if (GC_is_initialized.19 == 0) goto <D.5394>; else goto <D.5395>;
  <D.5394>:
  GC_init_inner ();
  <D.5395>:
  GC_incremental.20 = GC_incremental;
  if (GC_incremental.20 != 0) goto <D.5397>; else goto <D.5398>;
  <D.5397>:
  GC_dont_gc.21 = GC_dont_gc;
  if (GC_dont_gc.21 == 0) goto <D.5400>; else goto <D.5401>;
  <D.5400>:
  GC_collecting = 1;
  GC_collect_a_little_inner (1);
  GC_collecting = 0;
  <D.5401>:
  <D.5398>:
  {
    struct hblk * * rlh;
    struct hblk * hbp;
    struct hdr * hhdr;

    rlh = ok->ok_reclaim_list;
    D.5402 = lw * 4;
    rlh = rlh + D.5402;
    goto <D.5204>;
    <D.5203>:
    hbp.22 = (long unsigned int) hbp;
    D.5404 = hbp.22 >> 22;
    D.5405 = GC_arrays._top_index[D.5404];
    hbp.22 = (long unsigned int) hbp;
    D.5406 = hbp.22 >> 12;
    D.5407 = D.5406 & 1023;
    hhdr = D.5405->index[D.5407];
    D.5408 = hhdr->hb_next;
    *rlh = D.5408;
    GC_gc_no.23 = GC_gc_no;
    D.5410 = (short unsigned int) GC_gc_no.23;
    hhdr->hb_last_reclaimed = D.5410;
    D.5411 = ok->ok_init;
    op = GC_reclaim_generic (hbp, hhdr, lw, D.5411, 0);
    if (op != 0B) goto <D.5412>; else goto <D.5413>;
    <D.5412>:
    p = op;
    goto <D.5200>;
    <D.5199>:
    my_words_allocd = my_words_allocd + lw;
    p = MEM[(char * *)p];
    <D.5200>:
    if (p != 0B) goto <D.5199>; else goto <D.5201>;
    <D.5201>:
    D.5414 = GC_arrays._words_allocd;
    D.5415 = D.5414 + my_words_allocd;
    GC_arrays._words_allocd = D.5415;
    goto out;
    <D.5413>:
    <D.5204>:
    hbp = *rlh;
    if (hbp != 0B) goto <D.5203>; else goto <D.5205>;
    <D.5205>:
  }
  D.5416 = GC_obj_kinds[k].ok_freelist;
  D.5402 = lw * 4;
  opp = D.5416 + D.5402;
  op = *opp;
  if (op != 0B) goto <D.5417>; else goto <D.5418>;
  <D.5417>:
  *opp = 0B;
  my_words_allocd = 0;
  p = op;
  goto <D.5208>;
  <D.5207>:
  my_words_allocd = my_words_allocd + lw;
  if (my_words_allocd > 1023) goto <D.5419>; else goto <D.5420>;
  <D.5419>:
  D.5421 = MEM[(char * *)p];
  *opp = D.5421;
  MEM[(char * *)p] = 0B;
  goto <D.5206>;
  <D.5420>:
  p = MEM[(char * *)p];
  <D.5208>:
  if (p != 0B) goto <D.5207>; else goto <D.5206>;
  <D.5206>:
  D.5414 = GC_arrays._words_allocd;
  D.5415 = D.5414 + my_words_allocd;
  GC_arrays._words_allocd = D.5415;
  goto out;
  <D.5418>:
  {
    struct hblk * h;

    h = GC_allochblk (lw, k, 0);
    if (h != 0B) goto <D.5422>; else goto <D.5423>;
    <D.5422>:
    D.5424 = k & -2;
    if (D.5424 == 2) goto <D.5425>; else goto <D.5426>;
    <D.5425>:
    h.24 = (long unsigned int) h;
    D.5428 = h.24 >> 22;
    D.5429 = GC_arrays._top_index[D.5428];
    h.24 = (long unsigned int) h;
    D.5430 = h.24 >> 12;
    D.5431 = D.5430 & 1023;
    D.5432 = D.5429->index[D.5431];
    GC_set_hdr_marks (D.5432);
    <D.5426>:
    D.5414 = GC_arrays._words_allocd;
    D.5433 = 1024 % lw;
    D.5434 = D.5414 - D.5433;
    D.5435 = D.5434 + 1024;
    GC_arrays._words_allocd = D.5435;
    D.5411 = ok->ok_init;
    op = GC_build_fl (h, lw, D.5411, 0B);
    goto out;
    <D.5423>:
  }
  op = GC_generic_malloc_inner (lb, k);
  if (op != 0B) goto <D.5436>; else goto <D.5437>;
  <D.5436>:
  MEM[(char * *)op] = 0B;
  <D.5437>:
  out:
  *result = op;
  GC_clear (&GC_allocate_lock);
  GC_clear_stack (0);
}


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

  try
    {
      GC_generic_malloc_many (lb, 1, &result);
      D.5439 = result;
      return D.5439;
    }
  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.5444;
  int D.5451;
  char * D.5456;
  long unsigned int D.5457;
  long unsigned int D.5458;
  long unsigned int D.5459;
  long unsigned int GC_non_gc_bytes.27;
  long unsigned int GC_non_gc_bytes.28;
  void * D.5462;
  long unsigned int op.29;
  long unsigned int D.5467;
  long unsigned int h.30;
  long unsigned int D.5469;
  struct bottom_index * D.5470;
  long unsigned int D.5471;
  long unsigned int D.5472;
  struct hdr * D.5473;
  int D.5474;
  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.5444 = 2048 - GC_all_interior_pointers.26;
  if (D.5444 >= lb) goto <D.5445>; else goto <D.5446>;
  <D.5445>:
  GC_all_interior_pointers.25 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.25 != 0) goto <D.5447>; else goto <D.5448>;
  <D.5447>:
  if (lb != 0) goto <D.5449>; else goto <D.5450>;
  <D.5449>:
  lb = lb + 4294967295;
  <D.5450>:
  <D.5448>:
  lw = GC_arrays._size_map[lb];
  opp = &GC_arrays._uobjfreelist[lw];
  D.5451 = _test_and_set (&GC_allocate_lock, 1);
  if (D.5451 != 0) goto <D.5452>; else goto <D.5453>;
  <D.5452>:
  GC_lock ();
  <D.5453>:
  op = *opp;
  if (op != 0B) goto <D.5454>; else goto <D.5455>;
  <D.5454>:
  D.5456 = MEM[(char * *)op];
  *opp = D.5456;
  MEM[(char * *)op] = 0B;
  D.5457 = GC_arrays._words_allocd;
  D.5458 = D.5457 + lw;
  GC_arrays._words_allocd = D.5458;
  D.5459 = lw << 2;
  GC_non_gc_bytes.27 = GC_non_gc_bytes;
  GC_non_gc_bytes.28 = D.5459 + GC_non_gc_bytes.27;
  GC_non_gc_bytes = GC_non_gc_bytes.28;
  GC_clear (&GC_allocate_lock);
  D.5462 = op;
  return D.5462;
  <D.5455>:
  GC_clear (&GC_allocate_lock);
  op = GC_generic_malloc (lb, 2);
  goto <D.5463>;
  <D.5446>:
  op = GC_generic_malloc (lb, 2);
  <D.5463>:
  if (op == 0B) goto <D.5464>; else goto <D.5465>;
  <D.5464>:
  D.5462 = 0B;
  return D.5462;
  <D.5465>:
  {
    register struct hblk * h;

    op.29 = (long unsigned int) op;
    D.5467 = op.29 & 4294963200;
    h = (struct hblk *) D.5467;
    h.30 = (long unsigned int) h;
    D.5469 = h.30 >> 22;
    D.5470 = GC_arrays._top_index[D.5469];
    h.30 = (long unsigned int) h;
    D.5471 = h.30 >> 12;
    D.5472 = D.5471 & 1023;
    D.5473 = D.5470->index[D.5472];
    lw = D.5473->hb_sz;
    D.5474 = _test_and_set (&GC_allocate_lock, 1);
    if (D.5474 != 0) goto <D.5475>; else goto <D.5476>;
    <D.5475>:
    GC_lock ();
    <D.5476>:
    GC_set_mark_bit (op);
    D.5459 = lw << 2;
    GC_non_gc_bytes.27 = GC_non_gc_bytes;
    GC_non_gc_bytes.28 = D.5459 + GC_non_gc_bytes.27;
    GC_non_gc_bytes = GC_non_gc_bytes.28;
    GC_clear (&GC_allocate_lock);
    D.5462 = op;
    return D.5462;
  }
}


GC_memalign (size_t align, size_t lb)
{
  void * D.5482;
  void * (*<T623>) (size_t) GC_oom_fn.31;
  long unsigned int D.5491;
  unsigned int D.5492;
  long unsigned int result.32;
  int GC_all_interior_pointers.33;
  size_t new_lb;
  size_t offset;
  char * result;

  if (align <= 8) goto <D.5478>; else goto <D.5479>;
  <D.5478>:
  if (lb > align) goto <D.5480>; else goto <D.5481>;
  <D.5480>:
  D.5482 = GC_malloc (lb);
  return D.5482;
  <D.5481>:
  <D.5479>:
  if (align <= 4) goto <D.5483>; else goto <D.5484>;
  <D.5483>:
  D.5482 = GC_malloc (lb);
  return D.5482;
  <D.5484>:
  if (align > 2047) goto <D.5485>; else goto <D.5487>;
  <D.5487>:
  if (lb > 2047) goto <D.5485>; else goto <D.5486>;
  <D.5485>:
  if (align > 4096) goto <D.5488>; else goto <D.5489>;
  <D.5488>:
  GC_oom_fn.31 = GC_oom_fn;
  D.5482 = GC_oom_fn.31 (2147482623);
  return D.5482;
  <D.5489>:
  D.5491 = MAX_EXPR <lb, 4096>;
  D.5482 = GC_malloc (D.5491);
  return D.5482;
  <D.5486>:
  D.5492 = lb + align;
  new_lb = D.5492 + 4294967295;
  result = GC_malloc (new_lb);
  result.32 = (long unsigned int) result;
  offset = result.32 % align;
  if (offset != 0) goto <D.5494>; else goto <D.5495>;
  <D.5494>:
  offset = align - offset;
  GC_all_interior_pointers.33 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.33 == 0) goto <D.5497>; else goto <D.5498>;
  <D.5497>:
  if (offset > 2048) goto <D.5499>; else goto <D.5500>;
  <D.5499>:
  D.5482 = GC_malloc (4096);
  return D.5482;
  <D.5500>:
  GC_register_displacement (offset);
  <D.5498>:
  <D.5495>:
  result = result + offset;
  D.5482 = result;
  return D.5482;
}


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.5504;
  int D.5511;
  char * D.5516;
  long unsigned int D.5517;
  long unsigned int D.5518;
  long unsigned int D.5519;
  long unsigned int GC_non_gc_bytes.36;
  long unsigned int GC_non_gc_bytes.37;
  void * D.5522;
  long unsigned int op.38;
  long unsigned int D.5527;
  long unsigned int h.39;
  long unsigned int D.5529;
  struct bottom_index * D.5530;
  long unsigned int D.5531;
  long unsigned int D.5532;
  struct hdr * D.5533;
  int D.5534;
  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.5504 = 2048 - GC_all_interior_pointers.35;
  if (D.5504 >= lb) goto <D.5505>; else goto <D.5506>;
  <D.5505>:
  GC_all_interior_pointers.34 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.34 != 0) goto <D.5507>; else goto <D.5508>;
  <D.5507>:
  if (lb != 0) goto <D.5509>; else goto <D.5510>;
  <D.5509>:
  lb = lb + 4294967295;
  <D.5510>:
  <D.5508>:
  lw = GC_arrays._size_map[lb];
  opp = &GC_arrays._auobjfreelist[lw];
  D.5511 = _test_and_set (&GC_allocate_lock, 1);
  if (D.5511 != 0) goto <D.5512>; else goto <D.5513>;
  <D.5512>:
  GC_lock ();
  <D.5513>:
  op = *opp;
  if (op != 0B) goto <D.5514>; else goto <D.5515>;
  <D.5514>:
  D.5516 = MEM[(char * *)op];
  *opp = D.5516;
  MEM[(char * *)op] = 0B;
  D.5517 = GC_arrays._words_allocd;
  D.5518 = D.5517 + lw;
  GC_arrays._words_allocd = D.5518;
  D.5519 = lw << 2;
  GC_non_gc_bytes.36 = GC_non_gc_bytes;
  GC_non_gc_bytes.37 = D.5519 + GC_non_gc_bytes.36;
  GC_non_gc_bytes = GC_non_gc_bytes.37;
  GC_clear (&GC_allocate_lock);
  D.5522 = op;
  return D.5522;
  <D.5515>:
  GC_clear (&GC_allocate_lock);
  op = GC_generic_malloc (lb, 3);
  goto <D.5523>;
  <D.5506>:
  op = GC_generic_malloc (lb, 3);
  <D.5523>:
  if (op == 0B) goto <D.5524>; else goto <D.5525>;
  <D.5524>:
  D.5522 = 0B;
  return D.5522;
  <D.5525>:
  {
    register struct hblk * h;

    op.38 = (long unsigned int) op;
    D.5527 = op.38 & 4294963200;
    h = (struct hblk *) D.5527;
    h.39 = (long unsigned int) h;
    D.5529 = h.39 >> 22;
    D.5530 = GC_arrays._top_index[D.5529];
    h.39 = (long unsigned int) h;
    D.5531 = h.39 >> 12;
    D.5532 = D.5531 & 1023;
    D.5533 = D.5530->index[D.5532];
    lw = D.5533->hb_sz;
    D.5534 = _test_and_set (&GC_allocate_lock, 1);
    if (D.5534 != 0) goto <D.5535>; else goto <D.5536>;
    <D.5535>:
    GC_lock ();
    <D.5536>:
    GC_set_mark_bit (op);
    D.5519 = lw << 2;
    GC_non_gc_bytes.36 = GC_non_gc_bytes;
    GC_non_gc_bytes.37 = D.5519 + GC_non_gc_bytes.36;
    GC_non_gc_bytes = GC_non_gc_bytes.37;
    GC_clear (&GC_allocate_lock);
    D.5522 = op;
    return D.5522;
  }
}