GC_init_gcj_malloc (int mp_index, void * mp)
{
  int D.4519;
  int GC_gcj_malloc_initialized.0;
  char * D.4525;
  _Bool D.4526;
  int GC_print_stats.1;
  struct GC_ms_entry * (*<T73c>) (GC_word *, struct GC_ms_entry *, struct GC_ms_entry *, GC_word) mp.2;
  long unsigned int mp_index.3;
  long unsigned int GC_n_mark_procs.4;
  void * * GC_gcjobjfreelist.5;
  char * * GC_gcjobjfreelist.6;
  int GC_gcj_kind.7;
  int GC_gcj_kind.8;
  int GC_gcj_kind.9;
  void * * GC_gcjdebugobjfreelist.10;
  char * * GC_gcjdebugobjfreelist.11;
  int D.4550;
  int D.4551;
  int D.4552;
  long unsigned int D.4553;
  int GC_gcj_debug_kind.12;
  register int i;
  GC_bool ignore_gcj_info;

  GC_init ();
  D.4519 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4519 != 0) goto <D.4520>; else goto <D.4521>;
  <D.4520>:
  GC_lock ();
  <D.4521>:
  GC_gcj_malloc_initialized.0 = GC_gcj_malloc_initialized;
  if (GC_gcj_malloc_initialized.0 != 0) goto <D.4523>; else goto <D.4524>;
  <D.4523>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.4524>:
  GC_gcj_malloc_initialized = 1;
  D.4525 = getenv ("GC_IGNORE_GCJ_INFO");
  D.4526 = D.4525 != 0B;
  ignore_gcj_info = (GC_bool) D.4526;
  GC_print_stats.1 = GC_print_stats;
  if (GC_print_stats.1 != 0) goto <D.4528>; else goto <D.4529>;
  <D.4528>:
  if (ignore_gcj_info != 0) goto <D.4530>; else goto <D.4531>;
  <D.4530>:
  GC_printf ("Gcj-style type information is disabled!\n", 0, 0, 0, 0, 0, 0);
  <D.4531>:
  <D.4529>:
  mp.2 = (struct GC_ms_entry * (*<T73c>) (GC_word *, struct GC_ms_entry *, struct GC_ms_entry *, GC_word)) mp;
  GC_arrays._mark_procs[mp_index] = mp.2;
  mp_index.3 = (long unsigned int) mp_index;
  GC_n_mark_procs.4 = GC_n_mark_procs;
  if (mp_index.3 >= GC_n_mark_procs.4) goto <D.4535>; else goto <D.4536>;
  <D.4535>:
  GC_abort ("GC_init_gcj_malloc: bad index");
  <D.4536>:
  GC_gcjobjfreelist.5 = GC_new_free_list_inner ();
  GC_gcjobjfreelist = GC_gcjobjfreelist.5;
  if (ignore_gcj_info != 0) goto <D.4538>; else goto <D.4539>;
  <D.4538>:
  GC_gcjobjfreelist.6 = GC_gcjobjfreelist;
  GC_gcj_kind.7 = GC_new_kind_inner (GC_gcjobjfreelist.6, 0, 1, 1);
  GC_gcj_kind = GC_gcj_kind.7;
  goto <D.4542>;
  <D.4539>:
  GC_gcjobjfreelist.6 = GC_gcjobjfreelist;
  GC_gcj_kind.8 = GC_new_kind_inner (GC_gcjobjfreelist.6, 4294967279, 0, 1);
  GC_gcj_kind = GC_gcj_kind.8;
  <D.4542>:
  if (ignore_gcj_info != 0) goto <D.4544>; else goto <D.4545>;
  <D.4544>:
  GC_gcj_kind.9 = GC_gcj_kind;
  GC_gcj_debug_kind = GC_gcj_kind.9;
  GC_gcjobjfreelist.6 = GC_gcjobjfreelist;
  GC_gcjdebugobjfreelist = GC_gcjobjfreelist.6;
  goto <D.4547>;
  <D.4545>:
  GC_gcjdebugobjfreelist.10 = GC_new_free_list_inner ();
  GC_gcjdebugobjfreelist = GC_gcjdebugobjfreelist.10;
  GC_gcjdebugobjfreelist.11 = GC_gcjdebugobjfreelist;
  D.4550 = mp_index | 64;
  D.4551 = D.4550 << 2;
  D.4552 = D.4551 | 2;
  D.4553 = (long unsigned int) D.4552;
  GC_gcj_debug_kind.12 = GC_new_kind_inner (GC_gcjdebugobjfreelist.11, D.4553, 0, 1);
  GC_gcj_debug_kind = GC_gcj_debug_kind.12;
  <D.4547>:
  GC_clear (&GC_allocate_lock);
}


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


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


GC_gcj_malloc (size_t lb, void * ptr_to_struct_containing_descr)
{
  int GC_all_interior_pointers.13;
  long unsigned int GC_all_interior_pointers.14;
  long unsigned int D.4560;
  _Bool D.4561;
  long int D.4562;
  long int D.4563;
  char * * GC_gcjobjfreelist.15;
  long unsigned int D.4567;
  int D.4568;
  _Bool D.4571;
  long int D.4572;
  long int D.4573;
  int GC_gcj_kind.16;
  char * D.4577;
  void * D.4580;
  void * (*<T2ab>) (size_t) GC_oom_fn.17;
  char * D.4583;
  long unsigned int D.4584;
  long unsigned int D.4585;
  int D.4587;
  char * D.4590;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.13 = GC_all_interior_pointers;
  GC_all_interior_pointers.14 = (long unsigned int) GC_all_interior_pointers.13;
  D.4560 = 2048 - GC_all_interior_pointers.14;
  D.4561 = D.4560 >= lb;
  D.4562 = (long int) D.4561;
  D.4563 = __builtin_expect (D.4562, 1);
  if (D.4563 != 0) goto <D.4564>; else goto <D.4565>;
  <D.4564>:
  lw = GC_arrays._size_map[lb];
  GC_gcjobjfreelist.15 = GC_gcjobjfreelist;
  D.4567 = lw * 4;
  opp = GC_gcjobjfreelist.15 + D.4567;
  D.4568 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4568 != 0) goto <D.4569>; else goto <D.4570>;
  <D.4569>:
  GC_lock ();
  <D.4570>:
  op = *opp;
  D.4571 = op == 0B;
  D.4572 = (long int) D.4571;
  D.4573 = __builtin_expect (D.4572, 0);
  if (D.4573 != 0) goto <D.4574>; else goto <D.4575>;
  <D.4574>:
  maybe_finalize ();
  GC_gcj_kind.16 = GC_gcj_kind;
  D.4577 = GC_generic_malloc_inner (lb, GC_gcj_kind.16);
  op = GC_clear_stack (D.4577);
  if (op == 0B) goto <D.4578>; else goto <D.4579>;
  <D.4578>:
  GC_clear (&GC_allocate_lock);
  GC_oom_fn.17 = GC_oom_fn;
  D.4580 = GC_oom_fn.17 (lb);
  return D.4580;
  <D.4579>:
  lw = GC_arrays._size_map[lb];
  goto <D.4582>;
  <D.4575>:
  D.4583 = MEM[(char * *)op];
  *opp = D.4583;
  D.4584 = GC_arrays._words_allocd;
  D.4585 = D.4584 + lw;
  GC_arrays._words_allocd = D.4585;
  <D.4582>:
  MEM[(void * *)op] = ptr_to_struct_containing_descr;
  GC_clear (&GC_allocate_lock);
  goto <D.4586>;
  <D.4565>:
  D.4587 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4587 != 0) goto <D.4588>; else goto <D.4589>;
  <D.4588>:
  GC_lock ();
  <D.4589>:
  maybe_finalize ();
  GC_gcj_kind.16 = GC_gcj_kind;
  D.4590 = GC_generic_malloc_inner (lb, GC_gcj_kind.16);
  op = GC_clear_stack (D.4590);
  if (op == 0B) goto <D.4591>; else goto <D.4592>;
  <D.4591>:
  GC_clear (&GC_allocate_lock);
  GC_oom_fn.17 = GC_oom_fn;
  D.4580 = GC_oom_fn.17 (lb);
  return D.4580;
  <D.4592>:
  MEM[(void * *)op] = ptr_to_struct_containing_descr;
  GC_clear (&GC_allocate_lock);
  <D.4586>:
  D.4580 = op;
  return D.4580;
}


maybe_finalize ()
{
  int last_finalized_no.18;
  long unsigned int last_finalized_no.19;
  long unsigned int GC_gc_no.20;
  int GC_is_initialized.21;
  int GC_gc_no.22;
  int D.4603;
  static int last_finalized_no = 0;

  last_finalized_no.18 = last_finalized_no;
  last_finalized_no.19 = (long unsigned int) last_finalized_no.18;
  GC_gc_no.20 = GC_gc_no;
  if (last_finalized_no.19 == GC_gc_no.20) goto <D.4597>; else goto <D.4598>;
  <D.4597>:
  return;
  <D.4598>:
  GC_is_initialized.21 = GC_is_initialized;
  if (GC_is_initialized.21 == 0) goto <D.4600>; else goto <D.4601>;
  <D.4600>:
  return;
  <D.4601>:
  GC_clear (&GC_allocate_lock);
  GC_notify_or_invoke_finalizers ();
  GC_gc_no.20 = GC_gc_no;
  GC_gc_no.22 = (int) GC_gc_no.20;
  last_finalized_no = GC_gc_no.22;
  D.4603 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4603 != 0) goto <D.4604>; else goto <D.4605>;
  <D.4604>:
  GC_lock ();
  <D.4605>:
}


GC_debug_gcj_malloc (size_t lb, void * ptr_to_struct_containing_descr, const char * s, int i)
{
  int D.4607;
  int GC_all_interior_pointers.23;
  unsigned int GC_all_interior_pointers.24;
  unsigned int D.4612;
  unsigned int D.4613;
  int GC_gcj_debug_kind.25;
  long int lb.26;
  long int ptr_to_struct_containing_descr.27;
  void * D.4619;
  void * (*<T2ab>) (size_t) GC_oom_fn.28;
  void * * D.4621;
  int GC_debugging_started.29;
  long unsigned int i.30;
  void * result;

  D.4607 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4607 != 0) goto <D.4608>; else goto <D.4609>;
  <D.4608>:
  GC_lock ();
  <D.4609>:
  maybe_finalize ();
  GC_all_interior_pointers.23 = GC_all_interior_pointers;
  GC_all_interior_pointers.24 = (unsigned int) GC_all_interior_pointers.23;
  D.4612 = lb - GC_all_interior_pointers.24;
  D.4613 = D.4612 + 20;
  GC_gcj_debug_kind.25 = GC_gcj_debug_kind;
  result = GC_generic_malloc_inner (D.4613, GC_gcj_debug_kind.25);
  if (result == 0B) goto <D.4615>; else goto <D.4616>;
  <D.4615>:
  GC_clear (&GC_allocate_lock);
  lb.26 = (long int) lb;
  ptr_to_struct_containing_descr.27 = (long int) ptr_to_struct_containing_descr;
  GC_err_printf ("GC_debug_gcj_malloc(%ld, 0x%lx) returning NIL (", lb.26, ptr_to_struct_containing_descr.27, 0, 0, 0, 0);
  GC_err_puts (s);
  GC_err_printf (":%ld)\n", i, 0, 0, 0, 0, 0);
  GC_oom_fn.28 = GC_oom_fn;
  D.4619 = GC_oom_fn.28 (lb);
  return D.4619;
  <D.4616>:
  D.4621 = result + 16;
  *D.4621 = ptr_to_struct_containing_descr;
  GC_clear (&GC_allocate_lock);
  GC_debugging_started.29 = GC_debugging_started;
  if (GC_debugging_started.29 == 0) goto <D.4623>; else goto <D.4624>;
  <D.4623>:
  {
    extern int GC_start_debugging ();

    GC_start_debugging ();
  }
  <D.4624>:
  i.30 = (long unsigned int) i;
  D.4619 = GC_store_debug_info (result, lb, s, i.30);
  return D.4619;
}


GC_gcj_fast_malloc (size_t lw, void * ptr_to_struct_containing_descr)
{
  char * * GC_gcjobjfreelist.31;
  unsigned int D.4628;
  int D.4629;
  _Bool D.4632;
  long int D.4633;
  long int D.4634;
  int GC_gcj_kind.32;
  char * D.4638;
  void * D.4641;
  void * (*<T2ab>) (size_t) GC_oom_fn.33;
  unsigned int D.4643;
  char * D.4645;
  long unsigned int D.4646;
  long unsigned int D.4647;
  char * op;
  char * * opp;

  GC_gcjobjfreelist.31 = GC_gcjobjfreelist;
  D.4628 = lw * 4;
  opp = GC_gcjobjfreelist.31 + D.4628;
  D.4629 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4629 != 0) goto <D.4630>; else goto <D.4631>;
  <D.4630>:
  GC_lock ();
  <D.4631>:
  op = *opp;
  D.4632 = op == 0B;
  D.4633 = (long int) D.4632;
  D.4634 = __builtin_expect (D.4633, 0);
  if (D.4634 != 0) goto <D.4635>; else goto <D.4636>;
  <D.4635>:
  maybe_finalize ();
  GC_gcj_kind.32 = GC_gcj_kind;
  D.4638 = GC_generic_malloc_words_small_inner (lw, GC_gcj_kind.32);
  op = GC_clear_stack (D.4638);
  if (op == 0B) goto <D.4639>; else goto <D.4640>;
  <D.4639>:
  GC_clear (&GC_allocate_lock);
  GC_oom_fn.33 = GC_oom_fn;
  D.4643 = lw << 2;
  D.4641 = GC_oom_fn.33 (D.4643);
  return D.4641;
  <D.4640>:
  goto <D.4644>;
  <D.4636>:
  D.4645 = MEM[(char * *)op];
  *opp = D.4645;
  D.4646 = GC_arrays._words_allocd;
  D.4647 = D.4646 + lw;
  GC_arrays._words_allocd = D.4647;
  <D.4644>:
  MEM[(void * *)op] = ptr_to_struct_containing_descr;
  GC_clear (&GC_allocate_lock);
  D.4641 = op;
  return D.4641;
}


GC_debug_gcj_fast_malloc (size_t lw, void * ptr_to_struct_containing_descr, const char * s, int i)
{
  int D.4649;
  int GC_all_interior_pointers.34;
  unsigned int GC_all_interior_pointers.35;
  unsigned int D.4654;
  unsigned int D.4655;
  int GC_gcj_debug_kind.36;
  long int lw.37;
  long int ptr_to_struct_containing_descr.38;
  void * D.4661;
  void * (*<T2ab>) (size_t) GC_oom_fn.39;
  unsigned int D.4663;
  void * * D.4664;
  int GC_debugging_started.40;
  long unsigned int i.41;
  void * result;
  size_t lb;

  lb = lw << 2;
  D.4649 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4649 != 0) goto <D.4650>; else goto <D.4651>;
  <D.4650>:
  GC_lock ();
  <D.4651>:
  maybe_finalize ();
  GC_all_interior_pointers.34 = GC_all_interior_pointers;
  GC_all_interior_pointers.35 = (unsigned int) GC_all_interior_pointers.34;
  D.4654 = lb - GC_all_interior_pointers.35;
  D.4655 = D.4654 + 20;
  GC_gcj_debug_kind.36 = GC_gcj_debug_kind;
  result = GC_generic_malloc_inner (D.4655, GC_gcj_debug_kind.36);
  if (result == 0B) goto <D.4657>; else goto <D.4658>;
  <D.4657>:
  GC_clear (&GC_allocate_lock);
  lw.37 = (long int) lw;
  ptr_to_struct_containing_descr.38 = (long int) ptr_to_struct_containing_descr;
  GC_err_printf ("GC_debug_gcj_fast_malloc(%ld, 0x%lx) returning NIL (", lw.37, ptr_to_struct_containing_descr.38, 0, 0, 0, 0);
  GC_err_puts (s);
  GC_err_printf (":%ld)\n", i, 0, 0, 0, 0, 0);
  GC_oom_fn.39 = GC_oom_fn;
  D.4663 = lw << 2;
  D.4661 = GC_oom_fn.39 (D.4663);
  return D.4661;
  <D.4658>:
  D.4664 = result + 16;
  *D.4664 = ptr_to_struct_containing_descr;
  GC_clear (&GC_allocate_lock);
  GC_debugging_started.40 = GC_debugging_started;
  if (GC_debugging_started.40 == 0) goto <D.4666>; else goto <D.4667>;
  <D.4666>:
  {
    extern int GC_start_debugging ();

    GC_start_debugging ();
  }
  <D.4667>:
  i.41 = (long unsigned int) i;
  D.4661 = GC_store_debug_info (result, lb, s, i.41);
  return D.4661;
}


GC_gcj_malloc_ignore_off_page (size_t lb, void * ptr_to_struct_containing_descr)
{
  int GC_all_interior_pointers.42;
  long unsigned int GC_all_interior_pointers.43;
  long unsigned int D.4672;
  char * * GC_gcjobjfreelist.44;
  long unsigned int D.4676;
  int D.4677;
  int GC_gcj_kind.45;
  char * D.4683;
  char * D.4685;
  long unsigned int D.4686;
  long unsigned int D.4687;
  int D.4689;
  char * D.4692;
  void * D.4695;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.42 = GC_all_interior_pointers;
  GC_all_interior_pointers.43 = (long unsigned int) GC_all_interior_pointers.42;
  D.4672 = 2048 - GC_all_interior_pointers.43;
  if (D.4672 >= lb) goto <D.4673>; else goto <D.4674>;
  <D.4673>:
  lw = GC_arrays._size_map[lb];
  GC_gcjobjfreelist.44 = GC_gcjobjfreelist;
  D.4676 = lw * 4;
  opp = GC_gcjobjfreelist.44 + D.4676;
  D.4677 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4677 != 0) goto <D.4678>; else goto <D.4679>;
  <D.4678>:
  GC_lock ();
  <D.4679>:
  op = *opp;
  if (op == 0B) goto <D.4680>; else goto <D.4681>;
  <D.4680>:
  maybe_finalize ();
  GC_gcj_kind.45 = GC_gcj_kind;
  D.4683 = GC_generic_malloc_inner_ignore_off_page (lb, GC_gcj_kind.45);
  op = GC_clear_stack (D.4683);
  lw = GC_arrays._size_map[lb];
  goto <D.4684>;
  <D.4681>:
  D.4685 = MEM[(char * *)op];
  *opp = D.4685;
  D.4686 = GC_arrays._words_allocd;
  D.4687 = D.4686 + lw;
  GC_arrays._words_allocd = D.4687;
  <D.4684>:
  MEM[(void * *)op] = ptr_to_struct_containing_descr;
  GC_clear (&GC_allocate_lock);
  goto <D.4688>;
  <D.4674>:
  D.4689 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4689 != 0) goto <D.4690>; else goto <D.4691>;
  <D.4690>:
  GC_lock ();
  <D.4691>:
  maybe_finalize ();
  GC_gcj_kind.45 = GC_gcj_kind;
  D.4692 = GC_generic_malloc_inner_ignore_off_page (lb, GC_gcj_kind.45);
  op = GC_clear_stack (D.4692);
  if (op != 0B) goto <D.4693>; else goto <D.4694>;
  <D.4693>:
  MEM[(void * *)op] = ptr_to_struct_containing_descr;
  <D.4694>:
  GC_clear (&GC_allocate_lock);
  <D.4688>:
  D.4695 = op;
  return D.4695;
}