GC_add_ext_descriptor (GC_word * bm, word nbits)
{
  long unsigned int D.4660;
  int D.4661;
  signed_word D.4669;
  unsigned int D.4670;
  int D.4673;
  long unsigned int GC_ed_size.0;
  long unsigned int GC_avail_descr.1;
  struct ext_descr * GC_ext_descriptors.2;
  long unsigned int D.4683;
  long unsigned int GC_avail_descr.4;
  long unsigned int result.3;
  long unsigned int D.4686;
  long unsigned int D.4687;
  struct ext_descr * D.4688;
  long unsigned int D.4689;
  GC_word * D.4690;
  long unsigned int D.4691;
  unsigned int D.4692;
  long unsigned int D.4693;
  long unsigned int D.4694;
  register size_t nwords;
  register signed_word result;
  register word i;
  register word last_part;
  register int extra_bits;

  D.4660 = nbits + 31;
  nwords = D.4660 >> 5;
  D.4661 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4661 != 0) goto <D.4662>; else goto <D.4663>;
  <D.4662>:
  GC_lock ();
  <D.4663>:
  goto <D.4490>;
  <D.4489>:
  {
    struct ext_descr * new;
    size_t new_size;
    word ed_size;

    ed_size = GC_ed_size;
    GC_clear (&GC_allocate_lock);
    if (ed_size == 0) goto <D.4664>; else goto <D.4665>;
    <D.4664>:
    new_size = 100;
    goto <D.4666>;
    <D.4665>:
    new_size = ed_size * 2;
    if (new_size > 16777215) goto <D.4667>; else goto <D.4668>;
    <D.4667>:
    D.4669 = -1;
    return D.4669;
    <D.4668>:
    <D.4666>:
    D.4670 = new_size * 8;
    new = GC_malloc_atomic (D.4670);
    if (new == 0B) goto <D.4671>; else goto <D.4672>;
    <D.4671>:
    D.4669 = -1;
    return D.4669;
    <D.4672>:
    D.4673 = _test_and_set (&GC_allocate_lock, 1);
    if (D.4673 != 0) goto <D.4674>; else goto <D.4675>;
    <D.4674>:
    GC_lock ();
    <D.4675>:
    GC_ed_size.0 = GC_ed_size;
    if (ed_size == GC_ed_size.0) goto <D.4677>; else goto <D.4678>;
    <D.4677>:
    GC_avail_descr.1 = GC_avail_descr;
    if (GC_avail_descr.1 != 0) goto <D.4680>; else goto <D.4681>;
    <D.4680>:
    GC_ext_descriptors.2 = GC_ext_descriptors;
    GC_avail_descr.1 = GC_avail_descr;
    D.4683 = GC_avail_descr.1 * 8;
    memcpy (new, GC_ext_descriptors.2, D.4683);
    <D.4681>:
    GC_ed_size = new_size;
    GC_ext_descriptors = new;
    <D.4678>:
  }
  <D.4490>:
  GC_avail_descr.1 = GC_avail_descr;
  GC_avail_descr.4 = GC_avail_descr.1 + nwords;
  GC_ed_size.0 = GC_ed_size;
  if (GC_avail_descr.4 >= GC_ed_size.0) goto <D.4489>; else goto <D.4491>;
  <D.4491>:
  GC_avail_descr.1 = GC_avail_descr;
  result = (signed_word) GC_avail_descr.1;
  i = 0;
  goto <D.4493>;
  <D.4492>:
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.4686 = result.3 + i;
  D.4687 = D.4686 * 8;
  D.4688 = GC_ext_descriptors.2 + D.4687;
  D.4689 = i * 4;
  D.4690 = bm + D.4689;
  D.4691 = *D.4690;
  D.4688->ed_bitmap = D.4691;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.4686 = result.3 + i;
  D.4687 = D.4686 * 8;
  D.4688 = GC_ext_descriptors.2 + D.4687;
  D.4688->ed_continued = 1;
  i = i + 1;
  <D.4493>:
  D.4692 = nwords + 4294967295;
  if (D.4692 > i) goto <D.4492>; else goto <D.4494>;
  <D.4494>:
  D.4689 = i * 4;
  D.4690 = bm + D.4689;
  last_part = *D.4690;
  D.4693 = nwords * 32;
  D.4694 = D.4693 - nbits;
  extra_bits = (int) D.4694;
  last_part = last_part << extra_bits;
  last_part = last_part >> extra_bits;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.4686 = result.3 + i;
  D.4687 = D.4686 * 8;
  D.4688 = GC_ext_descriptors.2 + D.4687;
  D.4688->ed_bitmap = last_part;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.4686 = result.3 + i;
  D.4687 = D.4686 * 8;
  D.4688 = GC_ext_descriptors.2 + D.4687;
  D.4688->ed_continued = 0;
  GC_avail_descr.1 = GC_avail_descr;
  GC_avail_descr.4 = GC_avail_descr.1 + nwords;
  GC_avail_descr = GC_avail_descr.4;
  GC_clear (&GC_allocate_lock);
  D.4669 = result;
  return D.4669;
}


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


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

  D.4699 = __builtin_object_size (__dest, 0);
  D.4698 = __builtin___memcpy_chk (__dest, __src, __len, D.4699);
  return D.4698;
}


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


GC_double_descr (GC_descr descriptor, word nwords)
{
  long unsigned int D.4701;
  long unsigned int D.4704;
  long unsigned int D.4705;
  int nwords.5;
  long unsigned int D.4707;
  GC_descr D.4708;

  D.4701 = descriptor & 3;
  if (D.4701 == 0) goto <D.4702>; else goto <D.4703>;
  <D.4702>:
  D.4704 = descriptor >> 2;
  descriptor = GC_bm_table[D.4704];
  <D.4703>:
  D.4705 = descriptor & 4294967292;
  nwords.5 = (int) nwords;
  D.4707 = D.4705 >> nwords.5;
  descriptor = D.4707 | descriptor;
  D.4708 = descriptor;
  return D.4708;
}


GC_make_array_descriptor (word nelements, word size, GC_descr descriptor, GC_descr * simple_d, union complex_descriptor * * complex_d, struct LeafDescriptor * leaf)
{
  long unsigned int D.4710;
  long unsigned int D.4715;
  int D.4716;
  long unsigned int D.4730;
  long unsigned int D.4733;
  long unsigned int D.4734;
  long unsigned int D.4735;
  long unsigned int D.4736;
  long unsigned int D.4737;
  long unsigned int D.4745;
  union complex_descriptor * D.4746;
  long unsigned int D.4749;
  long unsigned int D.4750;
  long unsigned int D.4751;
  union complex_descriptor * D.4752;
  union complex_descriptor * D.4753;
  union complex_descriptor * D.4754;

  D.4710 = descriptor & 3;
  if (D.4710 == 0) goto <D.4711>; else goto <D.4712>;
  <D.4711>:
  if (descriptor == size) goto <D.4713>; else goto <D.4714>;
  <D.4713>:
  D.4715 = nelements * descriptor;
  *simple_d = D.4715;
  D.4716 = 0;
  return D.4716;
  <D.4714>:
  if (descriptor == 0) goto <D.4717>; else goto <D.4718>;
  <D.4717>:
  *simple_d = 0;
  D.4716 = 0;
  return D.4716;
  <D.4718>:
  <D.4712>:
  if (nelements <= 50) goto <D.4719>; else goto <D.4720>;
  <D.4719>:
  if (nelements <= 1) goto <D.4721>; else goto <D.4722>;
  <D.4721>:
  if (nelements == 1) goto <D.4723>; else goto <D.4724>;
  <D.4723>:
  *simple_d = descriptor;
  D.4716 = 0;
  return D.4716;
  <D.4724>:
  *simple_d = 0;
  D.4716 = 0;
  return D.4716;
  <D.4722>:
  goto <D.4725>;
  <D.4720>:
  if (size <= 15) goto <D.4726>; else goto <D.4727>;
  <D.4726>:
  D.4710 = descriptor & 3;
  if (D.4710 != 2) goto <D.4728>; else goto <D.4729>;
  <D.4728>:
  D.4730 = size & 3;
  if (D.4730 == 0) goto <D.4731>; else goto <D.4732>;
  <D.4731>:
  {
    int result;

    D.4733 = nelements / 2;
    D.4734 = size * 2;
    D.4735 = size >> 2;
    D.4736 = GC_double_descr (descriptor, D.4735);
    result = GC_make_array_descriptor (D.4733, D.4734, D.4736, simple_d, complex_d, leaf);
    D.4737 = nelements & 1;
    if (D.4737 == 0) goto <D.4738>; else goto <D.4739>;
    <D.4738>:
    D.4716 = result;
    return D.4716;
    <D.4739>:
    {
      struct LeafDescriptor * one_element;

      one_element = GC_malloc_atomic (16);
      if (result == -1) goto <D.4740>; else goto <D.4742>;
      <D.4742>:
      if (one_element == 0B) goto <D.4740>; else goto <D.4741>;
      <D.4740>:
      D.4716 = -1;
      return D.4716;
      <D.4741>:
      one_element->ld_tag = 1;
      one_element->ld_size = size;
      one_element->ld_nelements = 1;
      one_element->ld_descriptor = descriptor;
      switch (result) <default: <D.4755>, case 0: <D.4511>, case 1: <D.4514>, case 2: <D.4516>>
      <D.4511>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (16);
        if (beginning == 0B) goto <D.4743>; else goto <D.4744>;
        <D.4743>:
        D.4716 = -1;
        return D.4716;
        <D.4744>:
        beginning->ld_tag = 1;
        beginning->ld_size = size;
        beginning->ld_nelements = 1;
        D.4745 = *simple_d;
        beginning->ld_descriptor = D.4745;
        D.4746 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.4746;
        goto <D.4513>;
      }
      <D.4514>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (16);
        if (beginning == 0B) goto <D.4747>; else goto <D.4748>;
        <D.4747>:
        D.4716 = -1;
        return D.4716;
        <D.4748>:
        beginning->ld_tag = 1;
        D.4749 = leaf->ld_size;
        beginning->ld_size = D.4749;
        D.4750 = leaf->ld_nelements;
        beginning->ld_nelements = D.4750;
        D.4751 = leaf->ld_descriptor;
        beginning->ld_descriptor = D.4751;
        D.4752 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.4752;
        goto <D.4513>;
      }
      <D.4516>:
      D.4753 = *complex_d;
      D.4754 = GC_make_sequence_descriptor (D.4753, one_element);
      *complex_d = D.4754;
      goto <D.4513>;
      <D.4755>:
      <D.4513>:
      D.4716 = 2;
      return D.4716;
    }
  }
  <D.4732>:
  <D.4729>:
  <D.4727>:
  <D.4725>:
  leaf->ld_size = size;
  leaf->ld_nelements = nelements;
  leaf->ld_descriptor = descriptor;
  D.4716 = 1;
  return D.4716;
}


GC_make_sequence_descriptor (union complex_descriptor * first, union complex_descriptor * second)
{
  union complex_descriptor * D.4759;
  struct SequenceDescriptor * result;

  result = GC_malloc (12);
  if (result != 0B) goto <D.4757>; else goto <D.4758>;
  <D.4757>:
  result->sd_tag = 3;
  result->sd_first = first;
  result->sd_second = second;
  <D.4758>:
  D.4759 = result;
  return D.4759;
}


GC_init_explicit_typing ()
{
  int D.4761;
  int GC_explicit_typing_initialized.6;
  void * * GC_eobjfreelist.7;
  char * * GC_eobjfreelist.8;
  int GC_explicit_kind.9;
  int GC_typed_mark_proc_index.10;
  void * * GC_arobjfreelist.11;
  int GC_array_mark_proc_index.12;
  char * * GC_arobjfreelist.13;
  int GC_array_mark_proc_index.14;
  int D.4775;
  int D.4776;
  long unsigned int D.4777;
  int GC_array_kind.15;
  long unsigned int i.16;
  long unsigned int D.4780;
  int D.4781;
  long unsigned int D.4782;
  register int i;

  D.4761 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4761 != 0) goto <D.4762>; else goto <D.4763>;
  <D.4762>:
  GC_lock ();
  <D.4763>:
  GC_explicit_typing_initialized.6 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.6 != 0) goto <D.4765>; else goto <D.4766>;
  <D.4765>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.4766>:
  GC_explicit_typing_initialized = 1;
  GC_eobjfreelist.7 = GC_new_free_list_inner ();
  GC_eobjfreelist = GC_eobjfreelist.7;
  GC_eobjfreelist.8 = GC_eobjfreelist;
  GC_explicit_kind.9 = GC_new_kind_inner (GC_eobjfreelist.8, 4294967295, 1, 1);
  GC_explicit_kind = GC_explicit_kind.9;
  GC_typed_mark_proc_index.10 = GC_new_proc_inner (GC_typed_mark_proc);
  GC_typed_mark_proc_index = GC_typed_mark_proc_index.10;
  GC_arobjfreelist.11 = GC_new_free_list_inner ();
  GC_arobjfreelist = GC_arobjfreelist.11;
  GC_array_mark_proc_index.12 = GC_new_proc_inner (GC_array_mark_proc);
  GC_array_mark_proc_index = GC_array_mark_proc_index.12;
  GC_arobjfreelist.13 = GC_arobjfreelist;
  GC_array_mark_proc_index.14 = GC_array_mark_proc_index;
  D.4775 = GC_array_mark_proc_index.14 << 2;
  D.4776 = D.4775 | 2;
  D.4777 = (long unsigned int) D.4776;
  GC_array_kind.15 = GC_new_kind_inner (GC_arobjfreelist.13, D.4777, 0, 1);
  GC_array_kind = GC_array_kind.15;
  i = 0;
  goto <D.4539>;
  <D.4538>:
  {
    GC_descr d;

    i.16 = (long unsigned int) i;
    D.4780 = 32 - i.16;
    D.4781 = (int) D.4780;
    D.4782 = 4294967295 >> D.4781;
    i.16 = (long unsigned int) i;
    D.4780 = 32 - i.16;
    D.4781 = (int) D.4780;
    d = D.4782 << D.4781;
    d = d | 1;
    GC_bm_table[i] = d;
  }
  i = i + 1;
  <D.4539>:
  i.16 = (long unsigned int) i;
  if (i.16 <= 15) goto <D.4538>; else goto <D.4540>;
  <D.4540>:
  GC_clear (&GC_allocate_lock);
}


GC_typed_mark_proc (word * addr, struct mse * mark_stack_ptr, struct mse * mark_stack_limit, word env)
{
  struct ext_descr * GC_ext_descriptors.17;
  long unsigned int D.4785;
  struct ext_descr * D.4786;
  long unsigned int D.4787;
  char * current.18;
  long unsigned int my_current.19;
  long unsigned int D.4796;
  struct bottom_index * D.4797;
  long unsigned int D.4798;
  long unsigned int D.4799;
  long unsigned int my_hhdr.20;
  struct hdr * GC_invalid_header.21;
  int my_current.22;
  map_entry_type * D.4805;
  sizetype displ.23;
  map_entry_type * D.4807;
  unsigned char D.4808;
  long unsigned int displ.24;
  long unsigned int D.4814;
  long unsigned int D.4815;
  long unsigned int D.4816;
  int GC_all_interior_pointers.25;
  int D.4828;
  sizetype D.4829;
  int D.4830;
  long unsigned int D.4831;
  long unsigned int D.4833;
  unsigned int displ.26;
  unsigned int D.4840;
  sizetype my_current.27;
  sizetype D.4842;
  sizetype D.4843;
  GC_word * D.4844;
  int D.4845;
  GC_word * D.4850;
  long unsigned int D.4851;
  long unsigned int D.4852;
  int GC_typed_mark_proc_index.28;
  long unsigned int GC_typed_mark_proc_index.29;
  long unsigned int D.4855;
  long unsigned int D.4856;
  long unsigned int D.4857;
  struct mse * D.4858;
  register word bm;
  register word * current_p;
  register word current;
  register char * greatest_ha;
  register char * least_ha;
  void exit1 = <<< error >>>;

  GC_ext_descriptors.17 = GC_ext_descriptors;
  D.4785 = env * 8;
  D.4786 = GC_ext_descriptors.17 + D.4785;
  bm = D.4786->ed_bitmap;
  current_p = addr;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  goto <D.4563>;
  <D.4562>:
  D.4787 = bm & 1;
  if (D.4787 != 0) goto <D.4788>; else goto <D.4789>;
  <D.4788>:
  current = *current_p;
  current.18 = (char *) current;
  if (current.18 >= least_ha) goto <D.4791>; else goto <D.4792>;
  <D.4791>:
  current.18 = (char *) current;
  if (current.18 <= greatest_ha) goto <D.4793>; else goto <D.4794>;
  <D.4793>:
  {
    struct hdr * my_hhdr;
    char * my_current;

    my_current = (char *) current;
    my_current.19 = (long unsigned int) my_current;
    D.4796 = my_current.19 >> 22;
    D.4797 = GC_arrays._top_index[D.4796];
    my_current.19 = (long unsigned int) my_current;
    D.4798 = my_current.19 >> 12;
    D.4799 = D.4798 & 1023;
    my_hhdr = D.4797->index[D.4799];
    my_hhdr.20 = (long unsigned int) my_hhdr;
    if (my_hhdr.20 <= 4095) goto <D.4801>; else goto <D.4802>;
    <D.4801>:
    {
      struct hdr * new_hdr;

      try
        {
          GC_invalid_header.21 = GC_invalid_header;
          new_hdr = GC_invalid_header.21;
          my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
          my_hhdr = new_hdr;
        }
      finally
        {
          new_hdr = {CLOBBER};
        }
    }
    <D.4802>:
    {
      int displ;
      int map_entry;

      my_current.22 = (int) my_current;
      displ = my_current.22 & 4095;
      D.4805 = my_hhdr->hb_map;
      displ.23 = (sizetype) displ;
      D.4807 = D.4805 + displ.23;
      D.4808 = *D.4807;
      map_entry = (int) D.4808;
      displ = displ >> 2;
      if (map_entry > 253) goto <D.4809>; else goto <D.4810>;
      <D.4809>:
      if (map_entry == 254) goto <D.4811>; else goto <D.4812>;
      <D.4811>:
      displ.24 = (long unsigned int) displ;
      D.4814 = my_hhdr->hb_sz;
      D.4815 = displ.24 % D.4814;
      map_entry = (int) D.4815;
      displ = displ - map_entry;
      D.4814 = my_hhdr->hb_sz;
      displ.24 = (long unsigned int) displ;
      D.4816 = D.4814 + displ.24;
      if (D.4816 > 1024) goto <D.4817>; else goto <D.4818>;
      <D.4817>:
      GC_all_interior_pointers.25 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.25 != 0) goto <D.4820>; else goto <D.4821>;
      <D.4820>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.19);
      goto <D.4822>;
      <D.4821>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.19);
      <D.4822>:
      goto exit1;
      <D.4818>:
      goto <D.4823>;
      <D.4812>:
      GC_all_interior_pointers.25 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.25 != 0) goto <D.4824>; else goto <D.4825>;
      <D.4824>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.19);
      goto <D.4826>;
      <D.4825>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.19);
      <D.4826>:
      goto exit1;
      <D.4823>:
      goto <D.4827>;
      <D.4810>:
      displ = displ - map_entry;
      <D.4827>:
      {
        register word * mark_word_addr;

        D.4828 = displ >> 5;
        D.4829 = (sizetype) D.4828;
        mark_word_addr = &my_hhdr->hb_marks[D.4829];
        {
          word old;
          word my_bits;

          old = *mark_word_addr;
          D.4830 = displ & 31;
          my_bits = 1 << D.4830;
          D.4831 = old & my_bits;
          if (D.4831 != 0) goto exit1; else goto <D.4832>;
          <D.4832>:
          D.4833 = old | my_bits;
          *mark_word_addr = D.4833;
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.4834>; else goto <D.4835>;
        <D.4834>:
        goto <D.4836>;
        <D.4835>:
        mark_stack_ptr = mark_stack_ptr + 8;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.4837>; else goto <D.4838>;
        <D.4837>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.4838>:
        displ.26 = (unsigned int) displ;
        D.4840 = displ.26 * 4;
        my_current.27 = (sizetype) my_current;
        D.4842 = my_current.27 & 4294963200;
        D.4843 = D.4840 + D.4842;
        D.4844 = (GC_word *) D.4843;
        mark_stack_ptr->mse_start = D.4844;
        mark_stack_ptr->mse_descr = _descr;
        <D.4836>:
      }
    }
    exit1:
  }
  <D.4794>:
  <D.4792>:
  <D.4789>:
  bm = bm >> 1;
  current_p = current_p + 4;
  <D.4563>:
  if (bm != 0) goto <D.4562>; else goto <D.4564>;
  <D.4564>:
  GC_ext_descriptors.17 = GC_ext_descriptors;
  D.4785 = env * 8;
  D.4786 = GC_ext_descriptors.17 + D.4785;
  D.4845 = D.4786->ed_continued;
  if (D.4845 != 0) goto <D.4846>; else goto <D.4847>;
  <D.4846>:
  mark_stack_ptr = mark_stack_ptr + 8;
  if (mark_stack_ptr >= mark_stack_limit) goto <D.4848>; else goto <D.4849>;
  <D.4848>:
  mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
  <D.4849>:
  D.4850 = addr + 128;
  mark_stack_ptr->mse_start = D.4850;
  D.4851 = env + 1;
  D.4852 = D.4851 << 6;
  GC_typed_mark_proc_index.28 = GC_typed_mark_proc_index;
  GC_typed_mark_proc_index.29 = (long unsigned int) GC_typed_mark_proc_index.28;
  D.4855 = D.4852 | GC_typed_mark_proc_index.29;
  D.4856 = D.4855 << 2;
  D.4857 = D.4856 | 2;
  mark_stack_ptr->mse_descr = D.4857;
  <D.4847>:
  D.4858 = mark_stack_ptr;
  return D.4858;
}


GC_descr_obj_size (union complex_descriptor * d)
{
  long unsigned int D.4860;
  word D.4861;
  long unsigned int D.4862;
  long unsigned int D.4863;
  long unsigned int D.4864;
  union ComplexDescriptor * D.4865;
  long unsigned int D.4866;
  union ComplexDescriptor * D.4867;
  long unsigned int D.4868;
  union ComplexDescriptor * D.4869;
  long unsigned int D.4870;

  D.4860 = d->ld.ld_tag;
  switch (D.4860) <default: <D.4571>, case 1: <D.4568>, case 2: <D.4569>, case 3: <D.4570>>
  <D.4568>:
  D.4862 = d->ld.ld_nelements;
  D.4863 = d->ld.ld_size;
  D.4861 = D.4862 * D.4863;
  return D.4861;
  <D.4569>:
  D.4864 = d->ad.ad_nelements;
  D.4865 = d->ad.ad_element_descr;
  D.4866 = GC_descr_obj_size (D.4865);
  D.4861 = D.4864 * D.4866;
  return D.4861;
  <D.4570>:
  D.4867 = d->sd.sd_first;
  D.4868 = GC_descr_obj_size (D.4867);
  D.4869 = d->sd.sd_second;
  D.4870 = GC_descr_obj_size (D.4869);
  D.4861 = D.4868 + D.4870;
  return D.4861;
  <D.4571>:
  GC_abort ("Bad complex descriptor");
  D.4861 = 0;
  return D.4861;
}


GC_push_complex_descriptor (word * addr, union complex_descriptor * d, struct mse * msp, struct mse * msl)
{
  long unsigned int D.4872;
  int msl.30;
  int msp.31;
  int D.4875;
  int D.4876;
  int nelements.32;
  struct mse * D.4880;
  union ComplexDescriptor * D.4883;
  union ComplexDescriptor * D.4886;
  register char * current;
  register word nelements;
  register word sz;
  register word i;

  current = addr;
  D.4872 = d->ld.ld_tag;
  switch (D.4872) <default: <D.4593>, case 1: <D.4582>, case 2: <D.4587>, case 3: <D.4592>>
  <D.4582>:
  {
    register GC_descr descr;

    descr = d->ld.ld_descriptor;
    nelements = d->ld.ld_nelements;
    msl.30 = (int) msl;
    msp.31 = (int) msp;
    D.4875 = msl.30 - msp.31;
    D.4876 = D.4875 /[ex] 8;
    nelements.32 = (int) nelements;
    if (D.4876 <= nelements.32) goto <D.4878>; else goto <D.4879>;
    <D.4878>:
    D.4880 = 0B;
    return D.4880;
    <D.4879>:
    sz = d->ld.ld_size;
    i = 0;
    goto <D.4585>;
    <D.4584>:
    msp = msp + 8;
    msp->mse_start = current;
    msp->mse_descr = descr;
    current = current + sz;
    i = i + 1;
    <D.4585>:
    if (i < nelements) goto <D.4584>; else goto <D.4586>;
    <D.4586>:
    D.4880 = msp;
    return D.4880;
  }
  <D.4587>:
  {
    register union complex_descriptor * descr;

    descr = d->ad.ad_element_descr;
    nelements = d->ad.ad_nelements;
    sz = GC_descr_obj_size (descr);
    i = 0;
    goto <D.4590>;
    <D.4589>:
    msp = GC_push_complex_descriptor (current, descr, msp, msl);
    if (msp == 0B) goto <D.4881>; else goto <D.4882>;
    <D.4881>:
    D.4880 = 0B;
    return D.4880;
    <D.4882>:
    current = current + sz;
    i = i + 1;
    <D.4590>:
    if (i < nelements) goto <D.4589>; else goto <D.4591>;
    <D.4591>:
    D.4880 = msp;
    return D.4880;
  }
  <D.4592>:
  D.4883 = d->sd.sd_first;
  sz = GC_descr_obj_size (D.4883);
  D.4883 = d->sd.sd_first;
  msp = GC_push_complex_descriptor (current, D.4883, msp, msl);
  if (msp == 0B) goto <D.4884>; else goto <D.4885>;
  <D.4884>:
  D.4880 = 0B;
  return D.4880;
  <D.4885>:
  current = current + sz;
  D.4886 = d->sd.sd_second;
  msp = GC_push_complex_descriptor (current, D.4886, msp, msl);
  D.4880 = msp;
  return D.4880;
  <D.4593>:
  GC_abort ("Bad complex descriptor");
  D.4880 = 0B;
  return D.4880;
}


GC_array_mark_proc (word * addr, struct mse * mark_stack_ptr, struct mse * mark_stack_limit, word env)
{
  long unsigned int addr.33;
  long unsigned int D.4889;
  struct bottom_index * D.4890;
  long unsigned int D.4891;
  long unsigned int D.4892;
  sizetype D.4893;
  sizetype D.4894;
  word * D.4895;
  long unsigned int D.4896;
  struct mse * D.4899;
  struct mse * D.4900;
  long unsigned int D.4903;
  register struct hdr * hhdr;
  register word sz;
  register union complex_descriptor * descr;
  struct mse * orig_mark_stack_ptr;
  struct mse * new_mark_stack_ptr;

  addr.33 = (long unsigned int) addr;
  D.4889 = addr.33 >> 22;
  D.4890 = GC_arrays._top_index[D.4889];
  addr.33 = (long unsigned int) addr;
  D.4891 = addr.33 >> 12;
  D.4892 = D.4891 & 1023;
  hhdr = D.4890->index[D.4892];
  sz = hhdr->hb_sz;
  D.4893 = sz + 1073741823;
  D.4894 = D.4893 * 4;
  D.4895 = addr + D.4894;
  D.4896 = *D.4895;
  descr = (union complex_descriptor *) D.4896;
  orig_mark_stack_ptr = mark_stack_ptr;
  if (descr == 0B) goto <D.4897>; else goto <D.4898>;
  <D.4897>:
  D.4899 = orig_mark_stack_ptr;
  return D.4899;
  <D.4898>:
  D.4900 = mark_stack_limit + 4294967288;
  new_mark_stack_ptr = GC_push_complex_descriptor (addr, descr, mark_stack_ptr, D.4900);
  if (new_mark_stack_ptr == 0B) goto <D.4901>; else goto <D.4902>;
  <D.4901>:
  GC_mark_stack_too_small = 1;
  new_mark_stack_ptr = orig_mark_stack_ptr + 8;
  new_mark_stack_ptr->mse_start = addr;
  D.4903 = sz << 2;
  new_mark_stack_ptr->mse_descr = D.4903;
  goto <D.4904>;
  <D.4902>:
  new_mark_stack_ptr = new_mark_stack_ptr + 8;
  D.4893 = sz + 1073741823;
  D.4894 = D.4893 * 4;
  D.4895 = addr + D.4894;
  new_mark_stack_ptr->mse_start = D.4895;
  new_mark_stack_ptr->mse_descr = 4;
  <D.4904>:
  D.4899 = new_mark_stack_ptr;
  return D.4899;
}


GC_make_descriptor (GC_word * bm, size_t len)
{
  unsigned int D.4906;
  int GC_explicit_typing_initialized.34;
  long unsigned int last_set_bit.35;
  long unsigned int D.4912;
  long unsigned int D.4913;
  GC_word * D.4914;
  long unsigned int D.4915;
  int D.4916;
  long unsigned int D.4917;
  long unsigned int D.4918;
  GC_descr D.4921;
  unsigned int i.36;
  unsigned int D.4923;
  unsigned int D.4924;
  GC_word * D.4925;
  long unsigned int D.4926;
  int D.4927;
  long unsigned int D.4928;
  long unsigned int D.4929;
  long int D.4934;
  long int D.4935;
  long unsigned int D.4940;
  long unsigned int index.37;
  long unsigned int D.4944;
  int GC_typed_mark_proc_index.38;
  long unsigned int GC_typed_mark_proc_index.39;
  long unsigned int D.4947;
  long unsigned int D.4948;
  register signed_word last_set_bit;
  register word result;
  register int i;

  D.4906 = len + 4294967295;
  last_set_bit = (signed_word) D.4906;
  GC_explicit_typing_initialized.34 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.34 == 0) goto <D.4908>; else goto <D.4909>;
  <D.4908>:
  GC_init_explicit_typing ();
  <D.4909>:
  goto <D.4613>;
  <D.4612>:
  last_set_bit = last_set_bit + -1;
  <D.4613>:
  if (last_set_bit >= 0) goto <D.4910>; else goto <D.4614>;
  <D.4910>:
  last_set_bit.35 = (long unsigned int) last_set_bit;
  D.4912 = last_set_bit.35 / 32;
  D.4913 = D.4912 * 4;
  D.4914 = bm + D.4913;
  D.4915 = *D.4914;
  D.4916 = last_set_bit & 31;
  D.4917 = D.4915 >> D.4916;
  D.4918 = D.4917 & 1;
  if (D.4918 == 0) goto <D.4612>; else goto <D.4614>;
  <D.4614>:
  if (last_set_bit < 0) goto <D.4919>; else goto <D.4920>;
  <D.4919>:
  D.4921 = 0;
  return D.4921;
  <D.4920>:
  {
    register GC_bool all_bits_set;

    all_bits_set = 1;
    i = 0;
    goto <D.4618>;
    <D.4617>:
    i.36 = (unsigned int) i;
    D.4923 = i.36 / 32;
    D.4924 = D.4923 * 4;
    D.4925 = bm + D.4924;
    D.4926 = *D.4925;
    D.4927 = i & 31;
    D.4928 = D.4926 >> D.4927;
    D.4929 = D.4928 & 1;
    if (D.4929 == 0) goto <D.4930>; else goto <D.4931>;
    <D.4930>:
    all_bits_set = 0;
    goto <D.4616>;
    <D.4931>:
    i = i + 1;
    <D.4618>:
    if (i < last_set_bit) goto <D.4617>; else goto <D.4616>;
    <D.4616>:
    if (all_bits_set != 0) goto <D.4932>; else goto <D.4933>;
    <D.4932>:
    D.4934 = last_set_bit + 1;
    D.4935 = D.4934 << 2;
    D.4921 = (GC_descr) D.4935;
    return D.4921;
    <D.4933>:
  }
  last_set_bit.35 = (long unsigned int) last_set_bit;
  if (last_set_bit.35 <= 29) goto <D.4936>; else goto <D.4937>;
  <D.4936>:
  result = 2147483648;
  i = last_set_bit + -1;
  goto <D.4620>;
  <D.4619>:
  result = result >> 1;
  i.36 = (unsigned int) i;
  D.4923 = i.36 / 32;
  D.4924 = D.4923 * 4;
  D.4925 = bm + D.4924;
  D.4926 = *D.4925;
  D.4927 = i & 31;
  D.4928 = D.4926 >> D.4927;
  D.4929 = D.4928 & 1;
  if (D.4929 != 0) goto <D.4938>; else goto <D.4939>;
  <D.4938>:
  result = result | 2147483648;
  <D.4939>:
  i = i + -1;
  <D.4620>:
  if (i >= 0) goto <D.4619>; else goto <D.4621>;
  <D.4621>:
  result = result | 1;
  D.4921 = result;
  return D.4921;
  <D.4937>:
  {
    signed_word index;

    last_set_bit.35 = (long unsigned int) last_set_bit;
    D.4940 = last_set_bit.35 + 1;
    index = GC_add_ext_descriptor (bm, D.4940);
    if (index == -1) goto <D.4941>; else goto <D.4942>;
    <D.4941>:
    D.4934 = last_set_bit + 1;
    D.4935 = D.4934 << 2;
    D.4921 = (GC_descr) D.4935;
    return D.4921;
    <D.4942>:
    index.37 = (long unsigned int) index;
    D.4944 = index.37 << 6;
    GC_typed_mark_proc_index.38 = GC_typed_mark_proc_index;
    GC_typed_mark_proc_index.39 = (long unsigned int) GC_typed_mark_proc_index.38;
    D.4947 = D.4944 | GC_typed_mark_proc_index.39;
    D.4948 = D.4947 << 2;
    result = D.4948 | 2;
    D.4921 = result;
    return D.4921;
  }
}


GC_malloc_explicitly_typed (size_t lb, GC_descr d)
{
  int GC_all_interior_pointers.40;
  unsigned int GC_all_interior_pointers.41;
  unsigned int D.4952;
  long unsigned int GC_all_interior_pointers.42;
  long unsigned int D.4954;
  char * * GC_eobjfreelist.43;
  long unsigned int D.4958;
  int D.4959;
  int GC_explicit_kind.44;
  char * D.4965;
  void * D.4968;
  char * D.4970;
  long unsigned int D.4971;
  long unsigned int D.4972;
  char * D.4974;
  unsigned int D.4977;
  sizetype D.4980;
  sizetype D.4981;
  word * D.4982;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.40 = GC_all_interior_pointers;
  GC_all_interior_pointers.41 = (unsigned int) GC_all_interior_pointers.40;
  D.4952 = lb - GC_all_interior_pointers.41;
  lb = D.4952 + 4;
  GC_all_interior_pointers.40 = GC_all_interior_pointers;
  GC_all_interior_pointers.42 = (long unsigned int) GC_all_interior_pointers.40;
  D.4954 = 2048 - GC_all_interior_pointers.42;
  if (D.4954 >= lb) goto <D.4955>; else goto <D.4956>;
  <D.4955>:
  lw = GC_arrays._size_map[lb];
  GC_eobjfreelist.43 = GC_eobjfreelist;
  D.4958 = lw * 4;
  opp = GC_eobjfreelist.43 + D.4958;
  D.4959 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4959 != 0) goto <D.4960>; else goto <D.4961>;
  <D.4960>:
  GC_lock ();
  <D.4961>:
  op = *opp;
  if (op == 0B) goto <D.4962>; else goto <D.4963>;
  <D.4962>:
  GC_clear (&GC_allocate_lock);
  GC_explicit_kind.44 = GC_explicit_kind;
  D.4965 = GC_generic_malloc (lb, GC_explicit_kind.44);
  op = GC_clear_stack (D.4965);
  if (op == 0B) goto <D.4966>; else goto <D.4967>;
  <D.4966>:
  D.4968 = 0B;
  return D.4968;
  <D.4967>:
  lw = GC_arrays._size_map[lb];
  goto <D.4969>;
  <D.4963>:
  D.4970 = MEM[(char * *)op];
  *opp = D.4970;
  MEM[(char * *)op] = 0B;
  D.4971 = GC_arrays._words_allocd;
  D.4972 = D.4971 + lw;
  GC_arrays._words_allocd = D.4972;
  GC_clear (&GC_allocate_lock);
  <D.4969>:
  goto <D.4973>;
  <D.4956>:
  GC_explicit_kind.44 = GC_explicit_kind;
  D.4974 = GC_generic_malloc (lb, GC_explicit_kind.44);
  op = GC_clear_stack (D.4974);
  if (op != 0B) goto <D.4975>; else goto <D.4976>;
  <D.4975>:
  D.4977 = GC_size (op);
  lw = D.4977 >> 2;
  <D.4976>:
  <D.4973>:
  if (op != 0B) goto <D.4978>; else goto <D.4979>;
  <D.4978>:
  D.4980 = lw + 1073741823;
  D.4981 = D.4980 * 4;
  D.4982 = op + D.4981;
  *D.4982 = d;
  <D.4979>:
  D.4968 = op;
  return D.4968;
}


GC_malloc_explicitly_typed_ignore_off_page (size_t lb, GC_descr d)
{
  int GC_all_interior_pointers.45;
  unsigned int GC_all_interior_pointers.46;
  unsigned int D.4986;
  long unsigned int GC_all_interior_pointers.47;
  long unsigned int D.4988;
  char * * GC_eobjfreelist.48;
  long unsigned int D.4992;
  int D.4993;
  int GC_explicit_kind.49;
  char * D.4999;
  char * D.5001;
  long unsigned int D.5002;
  long unsigned int D.5003;
  char * D.5005;
  unsigned int D.5008;
  sizetype D.5011;
  sizetype D.5012;
  word * D.5013;
  void * D.5014;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.45 = GC_all_interior_pointers;
  GC_all_interior_pointers.46 = (unsigned int) GC_all_interior_pointers.45;
  D.4986 = lb - GC_all_interior_pointers.46;
  lb = D.4986 + 4;
  GC_all_interior_pointers.45 = GC_all_interior_pointers;
  GC_all_interior_pointers.47 = (long unsigned int) GC_all_interior_pointers.45;
  D.4988 = 2048 - GC_all_interior_pointers.47;
  if (D.4988 >= lb) goto <D.4989>; else goto <D.4990>;
  <D.4989>:
  lw = GC_arrays._size_map[lb];
  GC_eobjfreelist.48 = GC_eobjfreelist;
  D.4992 = lw * 4;
  opp = GC_eobjfreelist.48 + D.4992;
  D.4993 = _test_and_set (&GC_allocate_lock, 1);
  if (D.4993 != 0) goto <D.4994>; else goto <D.4995>;
  <D.4994>:
  GC_lock ();
  <D.4995>:
  op = *opp;
  if (op == 0B) goto <D.4996>; else goto <D.4997>;
  <D.4996>:
  GC_clear (&GC_allocate_lock);
  GC_explicit_kind.49 = GC_explicit_kind;
  D.4999 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.49);
  op = GC_clear_stack (D.4999);
  lw = GC_arrays._size_map[lb];
  goto <D.5000>;
  <D.4997>:
  D.5001 = MEM[(char * *)op];
  *opp = D.5001;
  MEM[(char * *)op] = 0B;
  D.5002 = GC_arrays._words_allocd;
  D.5003 = D.5002 + lw;
  GC_arrays._words_allocd = D.5003;
  GC_clear (&GC_allocate_lock);
  <D.5000>:
  goto <D.5004>;
  <D.4990>:
  GC_explicit_kind.49 = GC_explicit_kind;
  D.5005 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.49);
  op = GC_clear_stack (D.5005);
  if (op != 0B) goto <D.5006>; else goto <D.5007>;
  <D.5006>:
  D.5008 = GC_size (op);
  lw = D.5008 >> 2;
  <D.5007>:
  <D.5004>:
  if (op != 0B) goto <D.5009>; else goto <D.5010>;
  <D.5009>:
  D.5011 = lw + 1073741823;
  D.5012 = D.5011 * 4;
  D.5013 = op + D.5012;
  *D.5013 = d;
  <D.5010>:
  D.5014 = op;
  return D.5014;
}


GC_calloc_explicitly_typed (size_t n, size_t lb, GC_descr d)
{
  void * D.5016;
  unsigned int D.5017;
  long unsigned int simple_descr.50;
  int GC_all_interior_pointers.51;
  unsigned int GC_all_interior_pointers.52;
  unsigned int D.5021;
  long unsigned int GC_all_interior_pointers.53;
  long unsigned int D.5024;
  char * * GC_arobjfreelist.54;
  long unsigned int D.5028;
  int D.5029;
  int GC_array_kind.55;
  char * D.5035;
  char * D.5039;
  long unsigned int D.5040;
  long unsigned int D.5041;
  char * D.5043;
  unsigned int D.5046;
  sizetype D.5049;
  sizetype D.5050;
  long unsigned int D.5051;
  long unsigned int D.5052;
  long unsigned int D.5053;
  sizetype D.5054;
  sizetype D.5055;
  volatile word * D.5056;
  long unsigned int lp.56;
  word * D.5059;
  union complex_descriptor * complex_descr.57;
  long unsigned int complex_descr.58;
  void * * D.5062;
  unsigned int GC_finalization_failures.59;
  register char * op;
  register char * * opp;
  register word lw;
  GC_descr simple_descr;
  union complex_descriptor * complex_descr;
  register int descr_type;
  struct LeafDescriptor leaf;

  try
    {
      descr_type = GC_make_array_descriptor (n, lb, d, &simple_descr, &complex_descr, &leaf);
      switch (descr_type) <default: <D.5022>, case -1: <D.4650>, case 0: <D.4651>, case 1: <D.4652>, case 2: <D.4654>>
      <D.4650>:
      D.5016 = 0B;
      return D.5016;
      <D.4651>:
      D.5017 = n * lb;
      simple_descr.50 = simple_descr;
      D.5016 = GC_malloc_explicitly_typed (D.5017, simple_descr.50);
      return D.5016;
      <D.4652>:
      lb = lb * n;
      GC_all_interior_pointers.51 = GC_all_interior_pointers;
      GC_all_interior_pointers.52 = (unsigned int) GC_all_interior_pointers.51;
      D.5021 = lb - GC_all_interior_pointers.52;
      lb = D.5021 + 20;
      goto <D.4653>;
      <D.4654>:
      lb = lb * n;
      GC_all_interior_pointers.51 = GC_all_interior_pointers;
      GC_all_interior_pointers.52 = (unsigned int) GC_all_interior_pointers.51;
      D.5021 = lb - GC_all_interior_pointers.52;
      lb = D.5021 + 4;
      goto <D.4653>;
      <D.5022>:
      <D.4653>:
      GC_all_interior_pointers.51 = GC_all_interior_pointers;
      GC_all_interior_pointers.53 = (long unsigned int) GC_all_interior_pointers.51;
      D.5024 = 2048 - GC_all_interior_pointers.53;
      if (D.5024 >= lb) goto <D.5025>; else goto <D.5026>;
      <D.5025>:
      lw = GC_arrays._size_map[lb];
      GC_arobjfreelist.54 = GC_arobjfreelist;
      D.5028 = lw * 4;
      opp = GC_arobjfreelist.54 + D.5028;
      D.5029 = _test_and_set (&GC_allocate_lock, 1);
      if (D.5029 != 0) goto <D.5030>; else goto <D.5031>;
      <D.5030>:
      GC_lock ();
      <D.5031>:
      op = *opp;
      if (op == 0B) goto <D.5032>; else goto <D.5033>;
      <D.5032>:
      GC_clear (&GC_allocate_lock);
      GC_array_kind.55 = GC_array_kind;
      D.5035 = GC_generic_malloc (lb, GC_array_kind.55);
      op = GC_clear_stack (D.5035);
      if (op == 0B) goto <D.5036>; else goto <D.5037>;
      <D.5036>:
      D.5016 = 0B;
      return D.5016;
      <D.5037>:
      lw = GC_arrays._size_map[lb];
      goto <D.5038>;
      <D.5033>:
      D.5039 = MEM[(char * *)op];
      *opp = D.5039;
      MEM[(char * *)op] = 0B;
      D.5040 = GC_arrays._words_allocd;
      D.5041 = D.5040 + lw;
      GC_arrays._words_allocd = D.5041;
      GC_clear (&GC_allocate_lock);
      <D.5038>:
      goto <D.5042>;
      <D.5026>:
      GC_array_kind.55 = GC_array_kind;
      D.5043 = GC_generic_malloc (lb, GC_array_kind.55);
      op = GC_clear_stack (D.5043);
      if (op == 0B) goto <D.5044>; else goto <D.5045>;
      <D.5044>:
      D.5016 = 0B;
      return D.5016;
      <D.5045>:
      D.5046 = GC_size (op);
      lw = D.5046 >> 2;
      <D.5042>:
      if (descr_type == 1) goto <D.5047>; else goto <D.5048>;
      <D.5047>:
      {
        volatile struct LeafDescriptor * lp;

        D.5049 = lw + 1073741819;
        D.5050 = D.5049 * 4;
        lp = op + D.5050;
        lp->ld_tag = 1;
        D.5051 = leaf.ld_size;
        lp->ld_size = D.5051;
        D.5052 = leaf.ld_nelements;
        lp->ld_nelements = D.5052;
        D.5053 = leaf.ld_descriptor;
        lp->ld_descriptor = D.5053;
        D.5054 = lw + 1073741823;
        D.5055 = D.5054 * 4;
        D.5056 = op + D.5055;
        lp.56 = (long unsigned int) lp;
        *D.5056 = lp.56;
      }
      goto <D.5058>;
      <D.5048>:
      {
        extern unsigned int GC_finalization_failures;
        unsigned int ff;

        ff = GC_finalization_failures;
        D.5054 = lw + 1073741823;
        D.5055 = D.5054 * 4;
        D.5059 = op + D.5055;
        complex_descr.57 = complex_descr;
        complex_descr.58 = (long unsigned int) complex_descr.57;
        *D.5059 = complex_descr.58;
        D.5054 = lw + 1073741823;
        D.5055 = D.5054 * 4;
        D.5062 = op + D.5055;
        GC_general_register_disappearing_link (D.5062, op);
        GC_finalization_failures.59 = GC_finalization_failures;
        if (ff != GC_finalization_failures.59) goto <D.5064>; else goto <D.5065>;
        <D.5064>:
        D.5017 = n * lb;
        D.5016 = GC_malloc (D.5017);
        return D.5016;
        <D.5065>:
      }
      <D.5058>:
      D.5016 = op;
      return D.5016;
    }
  finally
    {
      simple_descr = {CLOBBER};
      complex_descr = {CLOBBER};
      leaf = {CLOBBER};
    }
}