GC_alloc_reclaim_list (struct obj_kind * kind)
{
  GC_bool D.5204;
  struct hblk * * result;

  result = GC_scratch_alloc (2052);
  if (result == 0B) goto <D.5202>; else goto <D.5203>;
  <D.5202>:
  D.5204 = 0;
  return D.5204;
  <D.5203>:
  memset (result, 0, 2052);
  kind->ok_reclaim_list = result;
  D.5204 = 1;
  return D.5204;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5208;
  int D.5213;
  void * D.5215;
  unsigned int D.5216;

  D.5208 = __builtin_constant_p (__len);
  if (D.5208 != 0) goto <D.5209>; else goto <D.5210>;
  <D.5209>:
  if (__len == 0) goto <D.5211>; else goto <D.5212>;
  <D.5211>:
  D.5213 = __builtin_constant_p (__ch);
  if (D.5213 == 0) goto <D.5206>; else goto <D.5214>;
  <D.5214>:
  if (__ch != 0) goto <D.5206>; else goto <D.5207>;
  <D.5206>:
  __warn_memset_zero_len ();
  D.5215 = __dest;
  return D.5215;
  <D.5207>:
  <D.5212>:
  <D.5210>:
  D.5216 = __builtin_object_size (__dest, 0);
  D.5215 = __builtin___memset_chk (__dest, __ch, __len, D.5216);
  return D.5215;
}


GC_alloc_large (word lw, int k, unsigned int flags)
{
  long unsigned int D.5218;
  long unsigned int D.5219;
  int GC_is_initialized.0;
  int GC_incremental.1;
  int GC_dont_gc.2;
  int n_blocks.3;
  _Bool D.5233;
  int D.5234;
  int D.5235;
  long unsigned int D.5239;
  long unsigned int D.5242;
  long unsigned int total_bytes.4;
  long unsigned int D.5244;
  long unsigned int D.5245;
  long unsigned int D.5248;
  int D.5249;
  long unsigned int D.5250;
  long unsigned int D.5251;
  long unsigned int D.5252;
  char * D.5253;
  struct hblk * h;
  word n_blocks;
  char * result;

  D.5218 = lw << 2;
  D.5219 = D.5218 + 4095;
  n_blocks = D.5219 >> 12;
  GC_is_initialized.0 = GC_is_initialized;
  if (GC_is_initialized.0 == 0) goto <D.5221>; else goto <D.5222>;
  <D.5221>:
  GC_init_inner ();
  <D.5222>:
  GC_incremental.1 = GC_incremental;
  if (GC_incremental.1 != 0) goto <D.5224>; else goto <D.5225>;
  <D.5224>:
  GC_dont_gc.2 = GC_dont_gc;
  if (GC_dont_gc.2 == 0) goto <D.5227>; else goto <D.5228>;
  <D.5227>:
  n_blocks.3 = (int) n_blocks;
  GC_collect_a_little_inner (n_blocks.3);
  <D.5228>:
  <D.5225>:
  h = GC_allochblk (lw, k, flags);
  if (h == 0B) goto <D.5230>; else goto <D.5231>;
  <D.5230>:
  GC_merge_unmapped ();
  h = GC_allochblk (lw, k, flags);
  <D.5231>:
  goto <D.5138>;
  <D.5137>:
  h = GC_allochblk (lw, k, flags);
  <D.5138>:
  if (h == 0B) goto <D.5232>; else goto <D.5139>;
  <D.5232>:
  D.5233 = flags != 0;
  D.5234 = (int) D.5233;
  D.5235 = GC_collect_or_expand (n_blocks, D.5234);
  if (D.5235 != 0) goto <D.5137>; else goto <D.5139>;
  <D.5139>:
  if (h == 0B) goto <D.5236>; else goto <D.5237>;
  <D.5236>:
  result = 0B;
  goto <D.5238>;
  <D.5237>:
  {
    int total_bytes;

    D.5239 = n_blocks * 4096;
    total_bytes = (int) D.5239;
    if (n_blocks > 1) goto <D.5240>; else goto <D.5241>;
    <D.5240>:
    D.5242 = GC_arrays._large_allocd_bytes;
    total_bytes.4 = (long unsigned int) total_bytes;
    D.5244 = D.5242 + total_bytes.4;
    GC_arrays._large_allocd_bytes = D.5244;
    D.5242 = GC_arrays._large_allocd_bytes;
    D.5245 = GC_arrays._max_large_allocd_bytes;
    if (D.5242 > D.5245) goto <D.5246>; else goto <D.5247>;
    <D.5246>:
    D.5242 = GC_arrays._large_allocd_bytes;
    GC_arrays._max_large_allocd_bytes = D.5242;
    <D.5247>:
    <D.5241>:
    result = &h->hb_body;
    D.5248 = GC_arrays._words_wasted;
    D.5249 = total_bytes >> 2;
    D.5250 = (long unsigned int) D.5249;
    D.5251 = D.5250 - lw;
    D.5252 = D.5248 + D.5251;
    GC_arrays._words_wasted = D.5252;
  }
  <D.5238>:
  D.5253 = result;
  return D.5253;
}


GC_alloc_large_and_clear (word lw, int k, unsigned int flags)
{
  long unsigned int D.5255;
  long unsigned int D.5256;
  char * D.5259;
  int GC_debugging_started.5;
  int D.5264;
  long unsigned int D.5265;
  char * result;
  word n_blocks;

  result = GC_alloc_large (lw, k, flags);
  D.5255 = lw << 2;
  D.5256 = D.5255 + 4095;
  n_blocks = D.5256 >> 12;
  if (result == 0B) goto <D.5257>; else goto <D.5258>;
  <D.5257>:
  D.5259 = 0B;
  return D.5259;
  <D.5258>:
  GC_debugging_started.5 = GC_debugging_started;
  if (GC_debugging_started.5 != 0) goto <D.5260>; else goto <D.5263>;
  <D.5263>:
  D.5264 = GC_obj_kinds[k].ok_init;
  if (D.5264 != 0) goto <D.5260>; else goto <D.5261>;
  <D.5260>:
  D.5265 = n_blocks * 4096;
  memset (result, 0, D.5265);
  <D.5261>:
  D.5259 = result;
  return D.5259;
}


GC_generic_malloc_inner (word lb, int k)
{
  int GC_all_interior_pointers.6;
  long unsigned int GC_all_interior_pointers.7;
  long unsigned int D.5269;
  unsigned int k.8;
  unsigned int D.5273;
  char * * D.5274;
  long unsigned int D.5275;
  unsigned int D.5278;
  int GC_is_initialized.9;
  char * D.5286;
  struct hblk * * D.5287;
  int D.5290;
  char * D.5293;
  long unsigned int D.5295;
  long unsigned int D.5296;
  long unsigned int D.5297;
  long unsigned int D.5298;
  register word lw;
  register char * op;
  register char * * opp;
  void out = <<< error >>>;

  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  GC_all_interior_pointers.7 = (long unsigned int) GC_all_interior_pointers.6;
  D.5269 = 2048 - GC_all_interior_pointers.7;
  if (D.5269 >= lb) goto <D.5270>; else goto <D.5271>;
  <D.5270>:
  {
    register struct obj_kind * kind;

    k.8 = (unsigned int) k;
    D.5273 = k.8 * 20;
    kind = &GC_obj_kinds + D.5273;
    lw = GC_arrays._size_map[lb];
    D.5274 = kind->ok_freelist;
    D.5275 = lw * 4;
    opp = D.5274 + D.5275;
    op = *opp;
    if (op == 0B) goto <D.5276>; else goto <D.5277>;
    <D.5276>:
    D.5278 = GC_arrays._size_map[lb];
    if (D.5278 == 0) goto <D.5279>; else goto <D.5280>;
    <D.5279>:
    GC_is_initialized.9 = GC_is_initialized;
    if (GC_is_initialized.9 == 0) goto <D.5282>; else goto <D.5283>;
    <D.5282>:
    GC_init_inner ();
    <D.5283>:
    D.5278 = GC_arrays._size_map[lb];
    if (D.5278 == 0) goto <D.5284>; else goto <D.5285>;
    <D.5284>:
    GC_extend_size_map (lb);
    <D.5285>:
    D.5286 = GC_generic_malloc_inner (lb, k);
    return D.5286;
    <D.5280>:
    D.5287 = kind->ok_reclaim_list;
    if (D.5287 == 0B) goto <D.5288>; else goto <D.5289>;
    <D.5288>:
    D.5290 = GC_alloc_reclaim_list (kind);
    if (D.5290 == 0) goto out; else goto <D.5291>;
    <D.5291>:
    <D.5289>:
    op = GC_allocobj (lw, k);
    if (op == 0B) goto out; else goto <D.5292>;
    <D.5292>:
    <D.5277>:
    D.5293 = MEM[(char * *)op];
    *opp = D.5293;
    MEM[(char * *)op] = 0B;
  }
  goto <D.5294>;
  <D.5271>:
  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  GC_all_interior_pointers.7 = (long unsigned int) GC_all_interior_pointers.6;
  D.5295 = GC_all_interior_pointers.7 + lb;
  D.5296 = D.5295 + 3;
  lw = D.5296 >> 2;
  op = GC_alloc_large_and_clear (lw, k, 0);
  <D.5294>:
  D.5297 = GC_arrays._words_allocd;
  D.5298 = D.5297 + lw;
  GC_arrays._words_allocd = D.5298;
  out:
  D.5286 = op;
  return D.5286;
}


GC_generic_malloc_inner_ignore_off_page (size_t lb, int k)
{
  char * D.5302;
  int GC_all_interior_pointers.10;
  unsigned int GC_all_interior_pointers.11;
  unsigned int D.5305;
  unsigned int D.5306;
  long unsigned int D.5307;
  long unsigned int D.5308;
  register word lw;
  char * op;

  if (lb <= 4096) goto <D.5300>; else goto <D.5301>;
  <D.5300>:
  D.5302 = GC_generic_malloc_inner (lb, k);
  return D.5302;
  <D.5301>:
  GC_all_interior_pointers.10 = GC_all_interior_pointers;
  GC_all_interior_pointers.11 = (unsigned int) GC_all_interior_pointers.10;
  D.5305 = GC_all_interior_pointers.11 + lb;
  D.5306 = D.5305 + 3;
  lw = D.5306 >> 2;
  op = GC_alloc_large_and_clear (lw, k, 1);
  D.5307 = GC_arrays._words_allocd;
  D.5308 = D.5307 + lw;
  GC_arrays._words_allocd = D.5308;
  D.5302 = op;
  return D.5302;
}


GC_generic_malloc (word lb, int k)
{
  int GC_have_errors.12;
  int GC_all_interior_pointers.13;
  long unsigned int GC_all_interior_pointers.14;
  long unsigned int D.5315;
  int D.5318;
  long unsigned int D.5322;
  long unsigned int D.5323;
  long unsigned int D.5324;
  long unsigned int D.5325;
  int D.5326;
  int GC_debugging_started.15;
  long unsigned int D.5334;
  word * D.5336;
  sizetype D.5337;
  sizetype D.5338;
  word * D.5339;
  sizetype D.5340;
  sizetype D.5341;
  word * D.5342;
  long unsigned int D.5343;
  long unsigned int D.5344;
  char * D.5353;
  void * (*<T623>) (size_t) GC_oom_fn.16;
  char * result;

  GC_have_errors.12 = GC_have_errors;
  if (GC_have_errors.12 != 0) goto <D.5311>; else goto <D.5312>;
  <D.5311>:
  GC_print_all_errors ();
  <D.5312>:
  GC_notify_or_invoke_finalizers ();
  GC_all_interior_pointers.13 = GC_all_interior_pointers;
  GC_all_interior_pointers.14 = (long unsigned int) GC_all_interior_pointers.13;
  D.5315 = 2048 - GC_all_interior_pointers.14;
  if (D.5315 >= lb) goto <D.5316>; else goto <D.5317>;
  <D.5316>:
  D.5318 = _test_and_set (&GC_allocate_lock, 1);
  if (D.5318 != 0) goto <D.5319>; else goto <D.5320>;
  <D.5319>:
  GC_lock ();
  <D.5320>:
  result = GC_generic_malloc_inner (lb, k);
  GC_clear (&GC_allocate_lock);
  goto <D.5321>;
  <D.5317>:
  {
    word lw;
    word n_blocks;
    GC_bool init;

    GC_all_interior_pointers.13 = GC_all_interior_pointers;
    GC_all_interior_pointers.14 = (long unsigned int) GC_all_interior_pointers.13;
    D.5322 = GC_all_interior_pointers.14 + lb;
    D.5323 = D.5322 + 3;
    lw = D.5323 >> 2;
    D.5324 = lw << 2;
    D.5325 = D.5324 + 4095;
    n_blocks = D.5325 >> 12;
    init = GC_obj_kinds[k].ok_init;
    D.5326 = _test_and_set (&GC_allocate_lock, 1);
    if (D.5326 != 0) goto <D.5327>; else goto <D.5328>;
    <D.5327>:
    GC_lock ();
    <D.5328>:
    result = GC_alloc_large (lw, k, 0);
    if (result != 0B) goto <D.5329>; else goto <D.5330>;
    <D.5329>:
    GC_debugging_started.15 = GC_debugging_started;
    if (GC_debugging_started.15 != 0) goto <D.5332>; else goto <D.5333>;
    <D.5332>:
    D.5334 = n_blocks * 4096;
    memset (result, 0, D.5334);
    goto <D.5335>;
    <D.5333>:
    MEM[(word *)result] = 0;
    D.5336 = result + 4;
    *D.5336 = 0;
    D.5337 = lw + 1073741823;
    D.5338 = D.5337 * 4;
    D.5339 = result + D.5338;
    *D.5339 = 0;
    D.5340 = lw + 1073741822;
    D.5341 = D.5340 * 4;
    D.5342 = result + D.5341;
    *D.5342 = 0;
    <D.5335>:
    <D.5330>:
    D.5343 = GC_arrays._words_allocd;
    D.5344 = D.5343 + lw;
    GC_arrays._words_allocd = D.5344;
    GC_clear (&GC_allocate_lock);
    if (init != 0) goto <D.5345>; else goto <D.5346>;
    <D.5345>:
    GC_debugging_started.15 = GC_debugging_started;
    if (GC_debugging_started.15 == 0) goto <D.5347>; else goto <D.5348>;
    <D.5347>:
    if (result != 0B) goto <D.5349>; else goto <D.5350>;
    <D.5349>:
    D.5334 = n_blocks * 4096;
    memset (result, 0, D.5334);
    <D.5350>:
    <D.5348>:
    <D.5346>:
  }
  <D.5321>:
  if (result == 0B) goto <D.5351>; else goto <D.5352>;
  <D.5351>:
  GC_oom_fn.16 = GC_oom_fn;
  D.5353 = GC_oom_fn.16 (lb);
  return D.5353;
  <D.5352>:
  D.5353 = result;
  return D.5353;
}


_test_and_set (int * __p, int __v)
{
  int D.5356;
  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.5356 = __r;
  return D.5356;
}


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


GC_malloc_atomic (size_t lb)
{
  int GC_all_interior_pointers.17;
  long unsigned int GC_all_interior_pointers.18;
  long unsigned int D.5360;
  _Bool D.5361;
  long int D.5362;
  long int D.5363;
  int D.5366;
  _Bool D.5369;
  long int D.5370;
  long int D.5371;
  void * D.5374;
  char * D.5375;
  char * D.5376;
  long unsigned int D.5377;
  long unsigned int D.5378;
  char * D.5379;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.17 = GC_all_interior_pointers;
  GC_all_interior_pointers.18 = (long unsigned int) GC_all_interior_pointers.17;
  D.5360 = 2048 - GC_all_interior_pointers.18;
  D.5361 = D.5360 >= lb;
  D.5362 = (long int) D.5361;
  D.5363 = __builtin_expect (D.5362, 1);
  if (D.5363 != 0) goto <D.5364>; else goto <D.5365>;
  <D.5364>:
  lw = GC_arrays._size_map[lb];
  opp = &GC_arrays._aobjfreelist[lw];
  D.5366 = _test_and_set (&GC_allocate_lock, 1);
  if (D.5366 != 0) goto <D.5367>; else goto <D.5368>;
  <D.5367>:
  GC_lock ();
  <D.5368>:
  op = *opp;
  D.5369 = op == 0B;
  D.5370 = (long int) D.5369;
  D.5371 = __builtin_expect (D.5370, 0);
  if (D.5371 != 0) goto <D.5372>; else goto <D.5373>;
  <D.5372>:
  GC_clear (&GC_allocate_lock);
  D.5375 = GC_generic_malloc (lb, 0);
  D.5374 = GC_clear_stack (D.5375);
  return D.5374;
  <D.5373>:
  D.5376 = MEM[(char * *)op];
  *opp = D.5376;
  D.5377 = GC_arrays._words_allocd;
  D.5378 = D.5377 + lw;
  GC_arrays._words_allocd = D.5378;
  GC_clear (&GC_allocate_lock);
  D.5374 = op;
  return D.5374;
  <D.5365>:
  D.5379 = GC_generic_malloc (lb, 0);
  D.5374 = GC_clear_stack (D.5379);
  return D.5374;
}


GC_malloc (size_t lb)
{
  int GC_all_interior_pointers.19;
  long unsigned int GC_all_interior_pointers.20;
  long unsigned int D.5383;
  _Bool D.5384;
  long int D.5385;
  long int D.5386;
  int D.5389;
  _Bool D.5392;
  long int D.5393;
  long int D.5394;
  void * D.5397;
  char * D.5398;
  char * D.5399;
  long unsigned int D.5400;
  long unsigned int D.5401;
  char * D.5402;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.19 = GC_all_interior_pointers;
  GC_all_interior_pointers.20 = (long unsigned int) GC_all_interior_pointers.19;
  D.5383 = 2048 - GC_all_interior_pointers.20;
  D.5384 = D.5383 >= lb;
  D.5385 = (long int) D.5384;
  D.5386 = __builtin_expect (D.5385, 1);
  if (D.5386 != 0) goto <D.5387>; else goto <D.5388>;
  <D.5387>:
  lw = GC_arrays._size_map[lb];
  opp = &GC_arrays._objfreelist[lw];
  D.5389 = _test_and_set (&GC_allocate_lock, 1);
  if (D.5389 != 0) goto <D.5390>; else goto <D.5391>;
  <D.5390>:
  GC_lock ();
  <D.5391>:
  op = *opp;
  D.5392 = op == 0B;
  D.5393 = (long int) D.5392;
  D.5394 = __builtin_expect (D.5393, 0);
  if (D.5394 != 0) goto <D.5395>; else goto <D.5396>;
  <D.5395>:
  GC_clear (&GC_allocate_lock);
  D.5398 = GC_generic_malloc (lb, 1);
  D.5397 = GC_clear_stack (D.5398);
  return D.5397;
  <D.5396>:
  D.5399 = MEM[(char * *)op];
  *opp = D.5399;
  MEM[(char * *)op] = 0B;
  D.5400 = GC_arrays._words_allocd;
  D.5401 = D.5400 + lw;
  GC_arrays._words_allocd = D.5401;
  GC_clear (&GC_allocate_lock);
  D.5397 = op;
  return D.5397;
  <D.5388>:
  D.5402 = GC_generic_malloc (lb, 1);
  D.5397 = GC_clear_stack (D.5402);
  return D.5397;
}


GC_free (void * p)
{
  long unsigned int p.21;
  long unsigned int D.5407;
  long unsigned int h.22;
  long unsigned int D.5409;
  struct bottom_index * D.5410;
  long unsigned int D.5411;
  long unsigned int D.5412;
  unsigned char D.5413;
  long unsigned int D.5414;
  long unsigned int sz.23;
  _Bool D.5416;
  long int D.5417;
  long int D.5418;
  int D.5421;
  long unsigned int D.5424;
  long unsigned int D.5425;
  int D.5426;
  long unsigned int GC_non_gc_bytes.24;
  long int D.5430;
  long unsigned int D.5431;
  long unsigned int GC_non_gc_bytes.25;
  int D.5433;
  void * D.5436;
  long int D.5437;
  long int D.5438;
  unsigned int D.5439;
  char * * D.5440;
  unsigned int sz.26;
  unsigned int D.5442;
  char * D.5443;
  int D.5445;
  register struct hblk * h;
  register struct hdr * hhdr;
  register signed_word sz;
  register char * * flh;
  register int knd;
  register struct obj_kind * ok;

  if (p == 0B) goto <D.5404>; else goto <D.5405>;
  <D.5404>:
  return;
  <D.5405>:
  p.21 = (long unsigned int) p;
  D.5407 = p.21 & 4294963200;
  h = (struct hblk *) D.5407;
  h.22 = (long unsigned int) h;
  D.5409 = h.22 >> 22;
  D.5410 = GC_arrays._top_index[D.5409];
  h.22 = (long unsigned int) h;
  D.5411 = h.22 >> 12;
  D.5412 = D.5411 & 1023;
  hhdr = D.5410->index[D.5412];
  D.5413 = hhdr->hb_obj_kind;
  knd = (int) D.5413;
  D.5414 = hhdr->hb_sz;
  sz = (signed_word) D.5414;
  ok = &GC_obj_kinds[knd];
  sz.23 = (long unsigned int) sz;
  D.5416 = sz.23 <= 512;
  D.5417 = (long int) D.5416;
  D.5418 = __builtin_expect (D.5417, 1);
  if (D.5418 != 0) goto <D.5419>; else goto <D.5420>;
  <D.5419>:
  D.5421 = _test_and_set (&GC_allocate_lock, 1);
  if (D.5421 != 0) goto <D.5422>; else goto <D.5423>;
  <D.5422>:
  GC_lock ();
  <D.5423>:
  D.5424 = GC_arrays._mem_freed;
  sz.23 = (long unsigned int) sz;
  D.5425 = D.5424 + sz.23;
  GC_arrays._mem_freed = D.5425;
  D.5426 = knd & -2;
  if (D.5426 == 2) goto <D.5427>; else goto <D.5428>;
  <D.5427>:
  GC_non_gc_bytes.24 = GC_non_gc_bytes;
  D.5430 = sz << 2;
  D.5431 = (long unsigned int) D.5430;
  GC_non_gc_bytes.25 = GC_non_gc_bytes.24 - D.5431;
  GC_non_gc_bytes = GC_non_gc_bytes.25;
  <D.5428>:
  D.5433 = ok->ok_init;
  if (D.5433 != 0) goto <D.5434>; else goto <D.5435>;
  <D.5434>:
  D.5436 = p + 4;
  D.5437 = sz + -1;
  D.5438 = D.5437 << 2;
  D.5439 = (unsigned int) D.5438;
  memset (D.5436, 0, D.5439);
  <D.5435>:
  D.5440 = ok->ok_freelist;
  sz.26 = (unsigned int) sz;
  D.5442 = sz.26 * 4;
  flh = D.5440 + D.5442;
  D.5443 = *flh;
  MEM[(char * *)p] = D.5443;
  *flh = p;
  GC_clear (&GC_allocate_lock);
  goto <D.5444>;
  <D.5420>:
  D.5445 = _test_and_set (&GC_allocate_lock, 1);
  if (D.5445 != 0) goto <D.5446>; else goto <D.5447>;
  <D.5446>:
  GC_lock ();
  <D.5447>:
  D.5424 = GC_arrays._mem_freed;
  sz.23 = (long unsigned int) sz;
  D.5425 = D.5424 + sz.23;
  GC_arrays._mem_freed = D.5425;
  D.5426 = knd & -2;
  if (D.5426 == 2) goto <D.5448>; else goto <D.5449>;
  <D.5448>:
  GC_non_gc_bytes.24 = GC_non_gc_bytes;
  D.5430 = sz << 2;
  D.5431 = (long unsigned int) D.5430;
  GC_non_gc_bytes.25 = GC_non_gc_bytes.24 - D.5431;
  GC_non_gc_bytes = GC_non_gc_bytes.25;
  <D.5449>:
  GC_freehblk (h);
  GC_clear (&GC_allocate_lock);
  <D.5444>:
}


GC_free_inner (void * p)
{
  long unsigned int p.27;
  long unsigned int D.5452;
  long unsigned int h.28;
  long unsigned int D.5454;
  struct bottom_index * D.5455;
  long unsigned int D.5456;
  long unsigned int D.5457;
  unsigned char D.5458;
  long unsigned int D.5459;
  long unsigned int sz.29;
  long unsigned int D.5463;
  long unsigned int D.5464;
  int D.5465;
  long unsigned int GC_non_gc_bytes.30;
  long int D.5469;
  long unsigned int D.5470;
  long unsigned int GC_non_gc_bytes.31;
  int D.5472;
  void * D.5475;
  long int D.5476;
  long int D.5477;
  unsigned int D.5478;
  char * * D.5479;
  unsigned int sz.32;
  unsigned int D.5481;
  char * D.5482;
  register struct hblk * h;
  register struct hdr * hhdr;
  register signed_word sz;
  register char * * flh;
  register int knd;
  register struct obj_kind * ok;

  p.27 = (long unsigned int) p;
  D.5452 = p.27 & 4294963200;
  h = (struct hblk *) D.5452;
  h.28 = (long unsigned int) h;
  D.5454 = h.28 >> 22;
  D.5455 = GC_arrays._top_index[D.5454];
  h.28 = (long unsigned int) h;
  D.5456 = h.28 >> 12;
  D.5457 = D.5456 & 1023;
  hhdr = D.5455->index[D.5457];
  D.5458 = hhdr->hb_obj_kind;
  knd = (int) D.5458;
  D.5459 = hhdr->hb_sz;
  sz = (signed_word) D.5459;
  ok = &GC_obj_kinds[knd];
  sz.29 = (long unsigned int) sz;
  if (sz.29 <= 512) goto <D.5461>; else goto <D.5462>;
  <D.5461>:
  D.5463 = GC_arrays._mem_freed;
  sz.29 = (long unsigned int) sz;
  D.5464 = D.5463 + sz.29;
  GC_arrays._mem_freed = D.5464;
  D.5465 = knd & -2;
  if (D.5465 == 2) goto <D.5466>; else goto <D.5467>;
  <D.5466>:
  GC_non_gc_bytes.30 = GC_non_gc_bytes;
  D.5469 = sz << 2;
  D.5470 = (long unsigned int) D.5469;
  GC_non_gc_bytes.31 = GC_non_gc_bytes.30 - D.5470;
  GC_non_gc_bytes = GC_non_gc_bytes.31;
  <D.5467>:
  D.5472 = ok->ok_init;
  if (D.5472 != 0) goto <D.5473>; else goto <D.5474>;
  <D.5473>:
  D.5475 = p + 4;
  D.5476 = sz + -1;
  D.5477 = D.5476 << 2;
  D.5478 = (unsigned int) D.5477;
  memset (D.5475, 0, D.5478);
  <D.5474>:
  D.5479 = ok->ok_freelist;
  sz.32 = (unsigned int) sz;
  D.5481 = sz.32 * 4;
  flh = D.5479 + D.5481;
  D.5482 = *flh;
  MEM[(char * *)p] = D.5482;
  *flh = p;
  goto <D.5483>;
  <D.5462>:
  D.5463 = GC_arrays._mem_freed;
  sz.29 = (long unsigned int) sz;
  D.5464 = D.5463 + sz.29;
  GC_arrays._mem_freed = D.5464;
  D.5465 = knd & -2;
  if (D.5465 == 2) goto <D.5484>; else goto <D.5485>;
  <D.5484>:
  GC_non_gc_bytes.30 = GC_non_gc_bytes;
  D.5469 = sz << 2;
  D.5470 = (long unsigned int) D.5469;
  GC_non_gc_bytes.31 = GC_non_gc_bytes.30 - D.5470;
  GC_non_gc_bytes = GC_non_gc_bytes.31;
  <D.5485>:
  GC_freehblk (h);
  <D.5483>:
}