GC_add_ext_descriptor (GC_word * bm, word nbits)
{
  long unsigned int D.4731;
  int D.4732;
  signed_word D.4740;
  unsigned int D.4741;
  int D.4744;
  long unsigned int GC_ed_size.0;
  long unsigned int GC_avail_descr.1;
  long unsigned int D.4753;
  struct ext_descr * GC_ext_descriptors.2;
  long unsigned int GC_avail_descr.4;
  long unsigned int result.3;
  long unsigned int D.4757;
  long unsigned int D.4758;
  struct ext_descr * D.4759;
  long unsigned int D.4760;
  GC_word * D.4761;
  long unsigned int D.4762;
  unsigned int D.4763;
  long unsigned int D.4764;
  long unsigned int D.4765;
  register size_t nwords;
  register signed_word result;
  register word i;
  register word last_part;
  register int extra_bits;

  D.4731 = nbits + 31;
  nwords = D.4731 >> 5;
  D.4732 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.4732 != 0) goto <D.4733>; else goto <D.4734>;
  <D.4733>:
  GC_lock ();
  <D.4734>:
  goto <D.4559>;
  <D.4558>:
  {
    struct ext_descr * new;
    size_t new_size;
    word ed_size;

    ed_size = GC_ed_size;
    pthread_mutex_unlock (&GC_allocate_ml);
    if (ed_size == 0) goto <D.4735>; else goto <D.4736>;
    <D.4735>:
    new_size = 100;
    goto <D.4737>;
    <D.4736>:
    new_size = ed_size * 2;
    if (new_size > 16777215) goto <D.4738>; else goto <D.4739>;
    <D.4738>:
    D.4740 = -1;
    return D.4740;
    <D.4739>:
    <D.4737>:
    D.4741 = new_size * 8;
    new = GC_malloc_atomic (D.4741);
    if (new == 0B) goto <D.4742>; else goto <D.4743>;
    <D.4742>:
    D.4740 = -1;
    return D.4740;
    <D.4743>:
    D.4744 = pthread_mutex_trylock (&GC_allocate_ml);
    if (D.4744 != 0) goto <D.4745>; else goto <D.4746>;
    <D.4745>:
    GC_lock ();
    <D.4746>:
    GC_ed_size.0 = GC_ed_size;
    if (ed_size == GC_ed_size.0) goto <D.4748>; else goto <D.4749>;
    <D.4748>:
    GC_avail_descr.1 = GC_avail_descr;
    if (GC_avail_descr.1 != 0) goto <D.4751>; else goto <D.4752>;
    <D.4751>:
    GC_avail_descr.1 = GC_avail_descr;
    D.4753 = GC_avail_descr.1 * 8;
    GC_ext_descriptors.2 = GC_ext_descriptors;
    memcpy (new, GC_ext_descriptors.2, D.4753);
    <D.4752>:
    GC_ed_size = new_size;
    GC_ext_descriptors = new;
    <D.4749>:
  }
  <D.4559>:
  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.4558>; else goto <D.4560>;
  <D.4560>:
  GC_avail_descr.1 = GC_avail_descr;
  result = (signed_word) GC_avail_descr.1;
  i = 0;
  goto <D.4562>;
  <D.4561>:
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.4757 = result.3 + i;
  D.4758 = D.4757 * 8;
  D.4759 = GC_ext_descriptors.2 + D.4758;
  D.4760 = i * 4;
  D.4761 = bm + D.4760;
  D.4762 = *D.4761;
  D.4759->ed_bitmap = D.4762;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.4757 = result.3 + i;
  D.4758 = D.4757 * 8;
  D.4759 = GC_ext_descriptors.2 + D.4758;
  D.4759->ed_continued = 1;
  i = i + 1;
  <D.4562>:
  D.4763 = nwords + 4294967295;
  if (D.4763 > i) goto <D.4561>; else goto <D.4563>;
  <D.4563>:
  D.4760 = i * 4;
  D.4761 = bm + D.4760;
  last_part = *D.4761;
  D.4764 = nwords * 32;
  D.4765 = D.4764 - nbits;
  extra_bits = (int) D.4765;
  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.4757 = result.3 + i;
  D.4758 = D.4757 * 8;
  D.4759 = GC_ext_descriptors.2 + D.4758;
  D.4759->ed_bitmap = last_part;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.4757 = result.3 + i;
  D.4758 = D.4757 * 8;
  D.4759 = GC_ext_descriptors.2 + D.4758;
  D.4759->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;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.4740 = result;
  return D.4740;
}


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

  D.4768 = __builtin_object_size (__dest, 0);
  D.4767 = __builtin___memcpy_chk (__dest, __src, __len, D.4768);
  return D.4767;
}


GC_double_descr (GC_descr descriptor, word nwords)
{
  long unsigned int D.4770;
  long unsigned int D.4773;
  long unsigned int D.4774;
  int nwords.5;
  long unsigned int D.4776;
  GC_descr D.4777;

  D.4770 = descriptor & 3;
  if (D.4770 == 0) goto <D.4771>; else goto <D.4772>;
  <D.4771>:
  D.4773 = descriptor >> 2;
  descriptor = GC_bm_table[D.4773];
  <D.4772>:
  D.4774 = descriptor & 4294967292;
  nwords.5 = (int) nwords;
  D.4776 = D.4774 >> nwords.5;
  descriptor = D.4776 | descriptor;
  D.4777 = descriptor;
  return D.4777;
}


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.4779;
  long unsigned int D.4784;
  int D.4785;
  long unsigned int D.4799;
  long unsigned int D.4802;
  long unsigned int D.4803;
  long unsigned int D.4804;
  long unsigned int D.4805;
  long unsigned int D.4806;
  _Bool D.4809;
  _Bool D.4810;
  _Bool D.4811;
  long unsigned int D.4816;
  union complex_descriptor * D.4817;
  long unsigned int D.4820;
  long unsigned int D.4821;
  long unsigned int D.4822;
  union complex_descriptor * D.4823;
  union complex_descriptor * D.4824;
  union complex_descriptor * D.4825;

  D.4779 = descriptor & 3;
  if (D.4779 == 0) goto <D.4780>; else goto <D.4781>;
  <D.4780>:
  if (descriptor == size) goto <D.4782>; else goto <D.4783>;
  <D.4782>:
  D.4784 = nelements * descriptor;
  *simple_d = D.4784;
  D.4785 = 0;
  return D.4785;
  <D.4783>:
  if (descriptor == 0) goto <D.4786>; else goto <D.4787>;
  <D.4786>:
  *simple_d = 0;
  D.4785 = 0;
  return D.4785;
  <D.4787>:
  <D.4781>:
  if (nelements <= 50) goto <D.4788>; else goto <D.4789>;
  <D.4788>:
  if (nelements <= 1) goto <D.4790>; else goto <D.4791>;
  <D.4790>:
  if (nelements == 1) goto <D.4792>; else goto <D.4793>;
  <D.4792>:
  *simple_d = descriptor;
  D.4785 = 0;
  return D.4785;
  <D.4793>:
  *simple_d = 0;
  D.4785 = 0;
  return D.4785;
  <D.4791>:
  goto <D.4794>;
  <D.4789>:
  if (size <= 15) goto <D.4795>; else goto <D.4796>;
  <D.4795>:
  D.4779 = descriptor & 3;
  if (D.4779 != 2) goto <D.4797>; else goto <D.4798>;
  <D.4797>:
  D.4799 = size & 3;
  if (D.4799 == 0) goto <D.4800>; else goto <D.4801>;
  <D.4800>:
  {
    int result;

    D.4802 = size >> 2;
    D.4803 = GC_double_descr (descriptor, D.4802);
    D.4804 = size * 2;
    D.4805 = nelements / 2;
    result = GC_make_array_descriptor (D.4805, D.4804, D.4803, simple_d, complex_d, leaf);
    D.4806 = nelements & 1;
    if (D.4806 == 0) goto <D.4807>; else goto <D.4808>;
    <D.4807>:
    D.4785 = result;
    return D.4785;
    <D.4808>:
    {
      struct LeafDescriptor * one_element;

      one_element = GC_malloc_atomic (16);
      D.4809 = result == -1;
      D.4810 = one_element == 0B;
      D.4811 = D.4809 | D.4810;
      if (D.4811 != 0) goto <D.4812>; else goto <D.4813>;
      <D.4812>:
      D.4785 = -1;
      return D.4785;
      <D.4813>:
      one_element->ld_tag = 1;
      one_element->ld_size = size;
      one_element->ld_nelements = 1;
      one_element->ld_descriptor = descriptor;
      switch (result) <default: <D.4826>, case 0: <D.4580>, case 1: <D.4583>, case 2: <D.4585>>
      <D.4580>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (16);
        if (beginning == 0B) goto <D.4814>; else goto <D.4815>;
        <D.4814>:
        D.4785 = -1;
        return D.4785;
        <D.4815>:
        beginning->ld_tag = 1;
        beginning->ld_size = size;
        beginning->ld_nelements = 1;
        D.4816 = *simple_d;
        beginning->ld_descriptor = D.4816;
        D.4817 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.4817;
        goto <D.4582>;
      }
      <D.4583>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (16);
        if (beginning == 0B) goto <D.4818>; else goto <D.4819>;
        <D.4818>:
        D.4785 = -1;
        return D.4785;
        <D.4819>:
        beginning->ld_tag = 1;
        D.4820 = leaf->ld_size;
        beginning->ld_size = D.4820;
        D.4821 = leaf->ld_nelements;
        beginning->ld_nelements = D.4821;
        D.4822 = leaf->ld_descriptor;
        beginning->ld_descriptor = D.4822;
        D.4823 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.4823;
        goto <D.4582>;
      }
      <D.4585>:
      D.4824 = *complex_d;
      D.4825 = GC_make_sequence_descriptor (D.4824, one_element);
      *complex_d = D.4825;
      goto <D.4582>;
      <D.4826>:
      <D.4582>:
      D.4785 = 2;
      return D.4785;
    }
  }
  <D.4801>:
  <D.4798>:
  <D.4796>:
  <D.4794>:
  leaf->ld_size = size;
  leaf->ld_nelements = nelements;
  leaf->ld_descriptor = descriptor;
  D.4785 = 1;
  return D.4785;
}


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

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


GC_init_explicit_typing ()
{
  int D.4832;
  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;
  int GC_array_mark_proc_index.13;
  int D.4845;
  int D.4846;
  long unsigned int D.4847;
  char * * GC_arobjfreelist.14;
  int GC_array_kind.15;
  long unsigned int i.16;
  long unsigned int D.4851;
  int D.4852;
  long unsigned int D.4853;
  register int i;

  D.4832 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.4832 != 0) goto <D.4833>; else goto <D.4834>;
  <D.4833>:
  GC_lock ();
  <D.4834>:
  GC_explicit_typing_initialized.6 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.6 != 0) goto <D.4836>; else goto <D.4837>;
  <D.4836>:
  pthread_mutex_unlock (&GC_allocate_ml);
  return;
  <D.4837>:
  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_array_mark_proc_index.13 = GC_array_mark_proc_index;
  D.4845 = GC_array_mark_proc_index.13 << 2;
  D.4846 = D.4845 | 2;
  D.4847 = (long unsigned int) D.4846;
  GC_arobjfreelist.14 = GC_arobjfreelist;
  GC_array_kind.15 = GC_new_kind_inner (GC_arobjfreelist.14, D.4847, 0, 1);
  GC_array_kind = GC_array_kind.15;
  i = 0;
  goto <D.4608>;
  <D.4607>:
  {
    GC_descr d;

    i.16 = (long unsigned int) i;
    D.4851 = 32 - i.16;
    D.4852 = (int) D.4851;
    D.4853 = 4294967295 >> D.4852;
    i.16 = (long unsigned int) i;
    D.4851 = 32 - i.16;
    D.4852 = (int) D.4851;
    d = D.4853 << D.4852;
    d = d | 1;
    GC_bm_table[i] = d;
  }
  i = i + 1;
  <D.4608>:
  i.16 = (long unsigned int) i;
  if (i.16 <= 15) goto <D.4607>; else goto <D.4609>;
  <D.4609>:
  pthread_mutex_unlock (&GC_allocate_ml);
}


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.4856;
  struct ext_descr * D.4857;
  long unsigned int D.4858;
  char * current.18;
  _Bool D.4862;
  _Bool D.4863;
  _Bool D.4864;
  long unsigned int my_current.19;
  long unsigned int D.4868;
  struct bottom_index * D.4869;
  long unsigned int D.4870;
  long unsigned int D.4871;
  long unsigned int my_hhdr.20;
  struct hdr * GC_invalid_header.21;
  int my_current.22;
  map_entry_type * D.4877;
  sizetype displ.23;
  map_entry_type * D.4879;
  unsigned char D.4880;
  long unsigned int displ.24;
  long unsigned int D.4886;
  long unsigned int D.4887;
  long unsigned int D.4888;
  int GC_all_interior_pointers.25;
  int D.4900;
  sizetype D.4901;
  int D.4902;
  long unsigned int D.4903;
  long unsigned int D.4905;
  int D.4906;
  unsigned int displ.26;
  unsigned int D.4913;
  sizetype my_current.27;
  sizetype D.4915;
  sizetype D.4916;
  GC_word * D.4917;
  int D.4918;
  GC_word * D.4923;
  long unsigned int D.4924;
  long unsigned int D.4925;
  int GC_typed_mark_proc_index.28;
  long unsigned int GC_typed_mark_proc_index.29;
  long unsigned int D.4928;
  long unsigned int D.4929;
  long unsigned int D.4930;
  struct mse * D.4931;
  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.4856 = env * 8;
  D.4857 = GC_ext_descriptors.17 + D.4856;
  bm = D.4857->ed_bitmap;
  current_p = addr;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  goto <D.4634>;
  <D.4633>:
  D.4858 = bm & 1;
  if (D.4858 != 0) goto <D.4859>; else goto <D.4860>;
  <D.4859>:
  current = *current_p;
  current.18 = (char *) current;
  D.4862 = current.18 >= least_ha;
  current.18 = (char *) current;
  D.4863 = current.18 <= greatest_ha;
  D.4864 = D.4862 & D.4863;
  if (D.4864 != 0) goto <D.4865>; else goto <D.4866>;
  <D.4865>:
  {
    struct hdr * my_hhdr;
    char * my_current;

    my_current = (char *) current;
    my_current.19 = (long unsigned int) my_current;
    D.4868 = my_current.19 >> 22;
    D.4869 = GC_arrays._top_index[D.4868];
    my_current.19 = (long unsigned int) my_current;
    D.4870 = my_current.19 >> 12;
    D.4871 = D.4870 & 1023;
    my_hhdr = D.4869->index[D.4871];
    my_hhdr.20 = (long unsigned int) my_hhdr;
    if (my_hhdr.20 <= 4095) goto <D.4873>; else goto <D.4874>;
    <D.4873>:
    {
      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.4874>:
    {
      int displ;
      int map_entry;

      my_current.22 = (int) my_current;
      displ = my_current.22 & 4095;
      D.4877 = my_hhdr->hb_map;
      displ.23 = (sizetype) displ;
      D.4879 = D.4877 + displ.23;
      D.4880 = *D.4879;
      map_entry = (int) D.4880;
      displ = displ >> 2;
      if (map_entry > 253) goto <D.4881>; else goto <D.4882>;
      <D.4881>:
      if (map_entry == 254) goto <D.4883>; else goto <D.4884>;
      <D.4883>:
      displ.24 = (long unsigned int) displ;
      D.4886 = my_hhdr->hb_sz;
      D.4887 = displ.24 % D.4886;
      map_entry = (int) D.4887;
      displ = displ - map_entry;
      D.4886 = my_hhdr->hb_sz;
      displ.24 = (long unsigned int) displ;
      D.4888 = D.4886 + displ.24;
      if (D.4888 > 1024) goto <D.4889>; else goto <D.4890>;
      <D.4889>:
      GC_all_interior_pointers.25 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.25 != 0) goto <D.4892>; else goto <D.4893>;
      <D.4892>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.19);
      goto <D.4894>;
      <D.4893>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.19);
      <D.4894>:
      goto exit1;
      <D.4890>:
      goto <D.4895>;
      <D.4884>:
      GC_all_interior_pointers.25 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.25 != 0) goto <D.4896>; else goto <D.4897>;
      <D.4896>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.19);
      goto <D.4898>;
      <D.4897>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.19);
      <D.4898>:
      goto exit1;
      <D.4895>:
      goto <D.4899>;
      <D.4882>:
      displ = displ - map_entry;
      <D.4899>:
      {
        register word * mark_word_addr;

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

          D.4902 = displ & 31;
          my_bits = 1 << D.4902;
          <D.4630>:
          old = MEM[(volatile word *)mark_word_addr];
          D.4903 = old & my_bits;
          if (D.4903 != 0) goto exit1; else goto <D.4904>;
          <D.4904>:
          D.4905 = old | my_bits;
          D.4906 = GC_compare_and_exchange (mark_word_addr, old, D.4905);
          if (D.4906 == 0) goto <D.4630>; else goto <D.4631>;
          <D.4631>:
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.4907>; else goto <D.4908>;
        <D.4907>:
        goto <D.4909>;
        <D.4908>:
        mark_stack_ptr = mark_stack_ptr + 8;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.4910>; else goto <D.4911>;
        <D.4910>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.4911>:
        displ.26 = (unsigned int) displ;
        D.4913 = displ.26 * 4;
        my_current.27 = (sizetype) my_current;
        D.4915 = my_current.27 & 4294963200;
        D.4916 = D.4913 + D.4915;
        D.4917 = (GC_word *) D.4916;
        mark_stack_ptr->mse_start = D.4917;
        mark_stack_ptr->mse_descr = _descr;
        <D.4909>:
      }
    }
    exit1:
  }
  <D.4866>:
  <D.4860>:
  bm = bm >> 1;
  current_p = current_p + 4;
  <D.4634>:
  if (bm != 0) goto <D.4633>; else goto <D.4635>;
  <D.4635>:
  GC_ext_descriptors.17 = GC_ext_descriptors;
  D.4856 = env * 8;
  D.4857 = GC_ext_descriptors.17 + D.4856;
  D.4918 = D.4857->ed_continued;
  if (D.4918 != 0) goto <D.4919>; else goto <D.4920>;
  <D.4919>:
  mark_stack_ptr = mark_stack_ptr + 8;
  if (mark_stack_ptr >= mark_stack_limit) goto <D.4921>; else goto <D.4922>;
  <D.4921>:
  mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
  <D.4922>:
  D.4923 = addr + 128;
  mark_stack_ptr->mse_start = D.4923;
  D.4924 = env + 1;
  D.4925 = D.4924 << 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.4928 = D.4925 | GC_typed_mark_proc_index.29;
  D.4929 = D.4928 << 2;
  D.4930 = D.4929 | 2;
  mark_stack_ptr->mse_descr = D.4930;
  <D.4920>:
  D.4931 = mark_stack_ptr;
  return D.4931;
}


GC_compare_and_exchange (volatile GC_word * addr, GC_word old, GC_word new_val)
{
  GC_bool D.4933;
  char result;

  __asm__ __volatile__("lock; cmpxchgl %2, %0; setz %1" : "=m" *addr, "=q" result : "r" new_val, "a" old, "m" *addr : "memory");
  D.4933 = (GC_bool) result;
  return D.4933;
}


GC_descr_obj_size (union complex_descriptor * d)
{
  long unsigned int D.4935;
  word D.4936;
  long unsigned int D.4937;
  long unsigned int D.4938;
  long unsigned int D.4939;
  union ComplexDescriptor * D.4940;
  long unsigned int D.4941;
  union ComplexDescriptor * D.4942;
  long unsigned int D.4943;
  union ComplexDescriptor * D.4944;
  long unsigned int D.4945;

  D.4935 = d->ld.ld_tag;
  switch (D.4935) <default: <D.4642>, case 1: <D.4639>, case 2: <D.4640>, case 3: <D.4641>>
  <D.4639>:
  D.4937 = d->ld.ld_nelements;
  D.4938 = d->ld.ld_size;
  D.4936 = D.4937 * D.4938;
  return D.4936;
  <D.4640>:
  D.4939 = d->ad.ad_nelements;
  D.4940 = d->ad.ad_element_descr;
  D.4941 = GC_descr_obj_size (D.4940);
  D.4936 = D.4939 * D.4941;
  return D.4936;
  <D.4641>:
  D.4942 = d->sd.sd_first;
  D.4943 = GC_descr_obj_size (D.4942);
  D.4944 = d->sd.sd_second;
  D.4945 = GC_descr_obj_size (D.4944);
  D.4936 = D.4943 + D.4945;
  return D.4936;
  <D.4642>:
  GC_abort ("Bad complex descriptor");
  D.4936 = 0;
  return D.4936;
}


GC_push_complex_descriptor (word * addr, union complex_descriptor * d, struct mse * msp, struct mse * msl)
{
  long unsigned int D.4947;
  int msl.30;
  int msp.31;
  int D.4950;
  int D.4951;
  int nelements.32;
  struct mse * D.4955;
  union ComplexDescriptor * D.4958;
  union ComplexDescriptor * D.4961;
  register char * current;
  register word nelements;
  register word sz;
  register word i;

  current = addr;
  D.4947 = d->ld.ld_tag;
  switch (D.4947) <default: <D.4664>, case 1: <D.4653>, case 2: <D.4658>, case 3: <D.4663>>
  <D.4653>:
  {
    register GC_descr descr;

    descr = d->ld.ld_descriptor;
    nelements = d->ld.ld_nelements;
    msl.30 = (int) msl;
    msp.31 = (int) msp;
    D.4950 = msl.30 - msp.31;
    D.4951 = D.4950 /[ex] 8;
    nelements.32 = (int) nelements;
    if (D.4951 <= nelements.32) goto <D.4953>; else goto <D.4954>;
    <D.4953>:
    D.4955 = 0B;
    return D.4955;
    <D.4954>:
    sz = d->ld.ld_size;
    i = 0;
    goto <D.4656>;
    <D.4655>:
    msp = msp + 8;
    msp->mse_start = current;
    msp->mse_descr = descr;
    current = current + sz;
    i = i + 1;
    <D.4656>:
    if (i < nelements) goto <D.4655>; else goto <D.4657>;
    <D.4657>:
    D.4955 = msp;
    return D.4955;
  }
  <D.4658>:
  {
    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.4661>;
    <D.4660>:
    msp = GC_push_complex_descriptor (current, descr, msp, msl);
    if (msp == 0B) goto <D.4956>; else goto <D.4957>;
    <D.4956>:
    D.4955 = 0B;
    return D.4955;
    <D.4957>:
    current = current + sz;
    i = i + 1;
    <D.4661>:
    if (i < nelements) goto <D.4660>; else goto <D.4662>;
    <D.4662>:
    D.4955 = msp;
    return D.4955;
  }
  <D.4663>:
  D.4958 = d->sd.sd_first;
  sz = GC_descr_obj_size (D.4958);
  D.4958 = d->sd.sd_first;
  msp = GC_push_complex_descriptor (current, D.4958, msp, msl);
  if (msp == 0B) goto <D.4959>; else goto <D.4960>;
  <D.4959>:
  D.4955 = 0B;
  return D.4955;
  <D.4960>:
  current = current + sz;
  D.4961 = d->sd.sd_second;
  msp = GC_push_complex_descriptor (current, D.4961, msp, msl);
  D.4955 = msp;
  return D.4955;
  <D.4664>:
  GC_abort ("Bad complex descriptor");
  D.4955 = 0B;
  return D.4955;
}


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.4964;
  struct bottom_index * D.4965;
  long unsigned int D.4966;
  long unsigned int D.4967;
  sizetype D.4968;
  sizetype D.4969;
  word * D.4970;
  long unsigned int D.4971;
  struct mse * D.4974;
  struct mse * D.4975;
  long unsigned int D.4978;
  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.4964 = addr.33 >> 22;
  D.4965 = GC_arrays._top_index[D.4964];
  addr.33 = (long unsigned int) addr;
  D.4966 = addr.33 >> 12;
  D.4967 = D.4966 & 1023;
  hhdr = D.4965->index[D.4967];
  sz = hhdr->hb_sz;
  D.4968 = sz + 1073741823;
  D.4969 = D.4968 * 4;
  D.4970 = addr + D.4969;
  D.4971 = *D.4970;
  descr = (union complex_descriptor *) D.4971;
  orig_mark_stack_ptr = mark_stack_ptr;
  if (descr == 0B) goto <D.4972>; else goto <D.4973>;
  <D.4972>:
  D.4974 = orig_mark_stack_ptr;
  return D.4974;
  <D.4973>:
  D.4975 = mark_stack_limit + 4294967288;
  new_mark_stack_ptr = GC_push_complex_descriptor (addr, descr, mark_stack_ptr, D.4975);
  if (new_mark_stack_ptr == 0B) goto <D.4976>; else goto <D.4977>;
  <D.4976>:
  GC_mark_stack_too_small = 1;
  new_mark_stack_ptr = orig_mark_stack_ptr + 8;
  new_mark_stack_ptr->mse_start = addr;
  D.4978 = sz << 2;
  new_mark_stack_ptr->mse_descr = D.4978;
  goto <D.4979>;
  <D.4977>:
  new_mark_stack_ptr = new_mark_stack_ptr + 8;
  D.4968 = sz + 1073741823;
  D.4969 = D.4968 * 4;
  D.4970 = addr + D.4969;
  new_mark_stack_ptr->mse_start = D.4970;
  new_mark_stack_ptr->mse_descr = 4;
  <D.4979>:
  D.4974 = new_mark_stack_ptr;
  return D.4974;
}


GC_make_descriptor (GC_word * bm, size_t len)
{
  unsigned int D.4981;
  int GC_explicit_typing_initialized.34;
  long unsigned int last_set_bit.35;
  long unsigned int D.4987;
  long unsigned int D.4988;
  GC_word * D.4989;
  long unsigned int D.4990;
  int D.4991;
  long unsigned int D.4992;
  long unsigned int D.4993;
  GC_descr D.4996;
  unsigned int i.36;
  unsigned int D.4998;
  unsigned int D.4999;
  GC_word * D.5000;
  long unsigned int D.5001;
  int D.5002;
  long unsigned int D.5003;
  long unsigned int D.5004;
  long int D.5009;
  long int D.5010;
  long unsigned int D.5015;
  long unsigned int index.37;
  long unsigned int D.5019;
  int GC_typed_mark_proc_index.38;
  long unsigned int GC_typed_mark_proc_index.39;
  long unsigned int D.5022;
  long unsigned int D.5023;
  register signed_word last_set_bit;
  register word result;
  register int i;

  D.4981 = len + 4294967295;
  last_set_bit = (signed_word) D.4981;
  GC_explicit_typing_initialized.34 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.34 == 0) goto <D.4983>; else goto <D.4984>;
  <D.4983>:
  GC_init_explicit_typing ();
  <D.4984>:
  goto <D.4684>;
  <D.4683>:
  last_set_bit = last_set_bit + -1;
  <D.4684>:
  if (last_set_bit >= 0) goto <D.4985>; else goto <D.4685>;
  <D.4985>:
  last_set_bit.35 = (long unsigned int) last_set_bit;
  D.4987 = last_set_bit.35 / 32;
  D.4988 = D.4987 * 4;
  D.4989 = bm + D.4988;
  D.4990 = *D.4989;
  D.4991 = last_set_bit & 31;
  D.4992 = D.4990 >> D.4991;
  D.4993 = D.4992 & 1;
  if (D.4993 == 0) goto <D.4683>; else goto <D.4685>;
  <D.4685>:
  if (last_set_bit < 0) goto <D.4994>; else goto <D.4995>;
  <D.4994>:
  D.4996 = 0;
  return D.4996;
  <D.4995>:
  {
    register GC_bool all_bits_set;

    all_bits_set = 1;
    i = 0;
    goto <D.4689>;
    <D.4688>:
    i.36 = (unsigned int) i;
    D.4998 = i.36 / 32;
    D.4999 = D.4998 * 4;
    D.5000 = bm + D.4999;
    D.5001 = *D.5000;
    D.5002 = i & 31;
    D.5003 = D.5001 >> D.5002;
    D.5004 = D.5003 & 1;
    if (D.5004 == 0) goto <D.5005>; else goto <D.5006>;
    <D.5005>:
    all_bits_set = 0;
    goto <D.4687>;
    <D.5006>:
    i = i + 1;
    <D.4689>:
    if (i < last_set_bit) goto <D.4688>; else goto <D.4687>;
    <D.4687>:
    if (all_bits_set != 0) goto <D.5007>; else goto <D.5008>;
    <D.5007>:
    D.5009 = last_set_bit + 1;
    D.5010 = D.5009 << 2;
    D.4996 = (GC_descr) D.5010;
    return D.4996;
    <D.5008>:
  }
  last_set_bit.35 = (long unsigned int) last_set_bit;
  if (last_set_bit.35 <= 29) goto <D.5011>; else goto <D.5012>;
  <D.5011>:
  result = 2147483648;
  i = last_set_bit + -1;
  goto <D.4691>;
  <D.4690>:
  result = result >> 1;
  i.36 = (unsigned int) i;
  D.4998 = i.36 / 32;
  D.4999 = D.4998 * 4;
  D.5000 = bm + D.4999;
  D.5001 = *D.5000;
  D.5002 = i & 31;
  D.5003 = D.5001 >> D.5002;
  D.5004 = D.5003 & 1;
  if (D.5004 != 0) goto <D.5013>; else goto <D.5014>;
  <D.5013>:
  result = result | 2147483648;
  <D.5014>:
  i = i + -1;
  <D.4691>:
  if (i >= 0) goto <D.4690>; else goto <D.4692>;
  <D.4692>:
  result = result | 1;
  D.4996 = result;
  return D.4996;
  <D.5012>:
  {
    signed_word index;

    last_set_bit.35 = (long unsigned int) last_set_bit;
    D.5015 = last_set_bit.35 + 1;
    index = GC_add_ext_descriptor (bm, D.5015);
    if (index == -1) goto <D.5016>; else goto <D.5017>;
    <D.5016>:
    D.5009 = last_set_bit + 1;
    D.5010 = D.5009 << 2;
    D.4996 = (GC_descr) D.5010;
    return D.4996;
    <D.5017>:
    index.37 = (long unsigned int) index;
    D.5019 = 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.5022 = D.5019 | GC_typed_mark_proc_index.39;
    D.5023 = D.5022 << 2;
    result = D.5023 | 2;
    D.4996 = result;
    return D.4996;
  }
}


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.5027;
  long unsigned int GC_all_interior_pointers.42;
  long unsigned int D.5029;
  char * * GC_eobjfreelist.43;
  long unsigned int D.5033;
  int D.5034;
  int GC_explicit_kind.44;
  char * D.5040;
  void * D.5043;
  char * D.5045;
  long unsigned int D.5046;
  long unsigned int D.5047;
  char * D.5049;
  unsigned int D.5052;
  sizetype D.5055;
  sizetype D.5056;
  word * D.5057;
  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.5027 = lb - GC_all_interior_pointers.41;
  lb = D.5027 + 4;
  GC_all_interior_pointers.40 = GC_all_interior_pointers;
  GC_all_interior_pointers.42 = (long unsigned int) GC_all_interior_pointers.40;
  D.5029 = 2048 - GC_all_interior_pointers.42;
  if (D.5029 >= lb) goto <D.5030>; else goto <D.5031>;
  <D.5030>:
  lw = GC_arrays._size_map[lb];
  GC_eobjfreelist.43 = GC_eobjfreelist;
  D.5033 = lw * 4;
  opp = GC_eobjfreelist.43 + D.5033;
  D.5034 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5034 != 0) goto <D.5035>; else goto <D.5036>;
  <D.5035>:
  GC_lock ();
  <D.5036>:
  op = *opp;
  if (op == 0B) goto <D.5037>; else goto <D.5038>;
  <D.5037>:
  pthread_mutex_unlock (&GC_allocate_ml);
  GC_explicit_kind.44 = GC_explicit_kind;
  D.5040 = GC_generic_malloc (lb, GC_explicit_kind.44);
  op = GC_clear_stack (D.5040);
  if (op == 0B) goto <D.5041>; else goto <D.5042>;
  <D.5041>:
  D.5043 = 0B;
  return D.5043;
  <D.5042>:
  lw = GC_arrays._size_map[lb];
  goto <D.5044>;
  <D.5038>:
  D.5045 = MEM[(char * *)op];
  *opp = D.5045;
  MEM[(char * *)op] = 0B;
  D.5046 = GC_arrays._words_allocd;
  D.5047 = D.5046 + lw;
  GC_arrays._words_allocd = D.5047;
  pthread_mutex_unlock (&GC_allocate_ml);
  <D.5044>:
  goto <D.5048>;
  <D.5031>:
  GC_explicit_kind.44 = GC_explicit_kind;
  D.5049 = GC_generic_malloc (lb, GC_explicit_kind.44);
  op = GC_clear_stack (D.5049);
  if (op != 0B) goto <D.5050>; else goto <D.5051>;
  <D.5050>:
  D.5052 = GC_size (op);
  lw = D.5052 >> 2;
  <D.5051>:
  <D.5048>:
  if (op != 0B) goto <D.5053>; else goto <D.5054>;
  <D.5053>:
  D.5055 = lw + 1073741823;
  D.5056 = D.5055 * 4;
  D.5057 = op + D.5056;
  *D.5057 = d;
  <D.5054>:
  D.5043 = op;
  return D.5043;
}


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.5061;
  long unsigned int GC_all_interior_pointers.47;
  long unsigned int D.5063;
  char * * GC_eobjfreelist.48;
  long unsigned int D.5067;
  int D.5068;
  int GC_explicit_kind.49;
  char * D.5074;
  char * D.5076;
  long unsigned int D.5077;
  long unsigned int D.5078;
  char * D.5080;
  unsigned int D.5083;
  sizetype D.5086;
  sizetype D.5087;
  word * D.5088;
  void * D.5089;
  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.5061 = lb - GC_all_interior_pointers.46;
  lb = D.5061 + 4;
  GC_all_interior_pointers.45 = GC_all_interior_pointers;
  GC_all_interior_pointers.47 = (long unsigned int) GC_all_interior_pointers.45;
  D.5063 = 2048 - GC_all_interior_pointers.47;
  if (D.5063 >= lb) goto <D.5064>; else goto <D.5065>;
  <D.5064>:
  lw = GC_arrays._size_map[lb];
  GC_eobjfreelist.48 = GC_eobjfreelist;
  D.5067 = lw * 4;
  opp = GC_eobjfreelist.48 + D.5067;
  D.5068 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5068 != 0) goto <D.5069>; else goto <D.5070>;
  <D.5069>:
  GC_lock ();
  <D.5070>:
  op = *opp;
  if (op == 0B) goto <D.5071>; else goto <D.5072>;
  <D.5071>:
  pthread_mutex_unlock (&GC_allocate_ml);
  GC_explicit_kind.49 = GC_explicit_kind;
  D.5074 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.49);
  op = GC_clear_stack (D.5074);
  lw = GC_arrays._size_map[lb];
  goto <D.5075>;
  <D.5072>:
  D.5076 = MEM[(char * *)op];
  *opp = D.5076;
  MEM[(char * *)op] = 0B;
  D.5077 = GC_arrays._words_allocd;
  D.5078 = D.5077 + lw;
  GC_arrays._words_allocd = D.5078;
  pthread_mutex_unlock (&GC_allocate_ml);
  <D.5075>:
  goto <D.5079>;
  <D.5065>:
  GC_explicit_kind.49 = GC_explicit_kind;
  D.5080 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.49);
  op = GC_clear_stack (D.5080);
  if (op != 0B) goto <D.5081>; else goto <D.5082>;
  <D.5081>:
  D.5083 = GC_size (op);
  lw = D.5083 >> 2;
  <D.5082>:
  <D.5079>:
  if (op != 0B) goto <D.5084>; else goto <D.5085>;
  <D.5084>:
  D.5086 = lw + 1073741823;
  D.5087 = D.5086 * 4;
  D.5088 = op + D.5087;
  *D.5088 = d;
  <D.5085>:
  D.5089 = op;
  return D.5089;
}


GC_calloc_explicitly_typed (size_t n, size_t lb, GC_descr d)
{
  void * D.5091;
  long unsigned int simple_descr.50;
  unsigned int D.5093;
  int GC_all_interior_pointers.51;
  unsigned int GC_all_interior_pointers.52;
  unsigned int D.5096;
  long unsigned int GC_all_interior_pointers.53;
  long unsigned int D.5099;
  char * * GC_arobjfreelist.54;
  long unsigned int D.5103;
  int D.5104;
  int GC_array_kind.55;
  char * D.5110;
  char * D.5114;
  long unsigned int D.5115;
  long unsigned int D.5116;
  char * D.5118;
  unsigned int D.5121;
  sizetype D.5124;
  sizetype D.5125;
  long unsigned int D.5126;
  long unsigned int D.5127;
  long unsigned int D.5128;
  sizetype D.5129;
  sizetype D.5130;
  volatile word * D.5131;
  long unsigned int lp.56;
  word * D.5134;
  union complex_descriptor * complex_descr.57;
  long unsigned int complex_descr.58;
  void * * D.5137;
  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.5097>, case -1: <D.4721>, case 0: <D.4722>, case 1: <D.4723>, case 2: <D.4725>>
      <D.4721>:
      D.5091 = 0B;
      return D.5091;
      <D.4722>:
      simple_descr.50 = simple_descr;
      D.5093 = n * lb;
      D.5091 = GC_malloc_explicitly_typed (D.5093, simple_descr.50);
      return D.5091;
      <D.4723>:
      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.5096 = lb - GC_all_interior_pointers.52;
      lb = D.5096 + 20;
      goto <D.4724>;
      <D.4725>:
      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.5096 = lb - GC_all_interior_pointers.52;
      lb = D.5096 + 4;
      goto <D.4724>;
      <D.5097>:
      <D.4724>:
      GC_all_interior_pointers.51 = GC_all_interior_pointers;
      GC_all_interior_pointers.53 = (long unsigned int) GC_all_interior_pointers.51;
      D.5099 = 2048 - GC_all_interior_pointers.53;
      if (D.5099 >= lb) goto <D.5100>; else goto <D.5101>;
      <D.5100>:
      lw = GC_arrays._size_map[lb];
      GC_arobjfreelist.54 = GC_arobjfreelist;
      D.5103 = lw * 4;
      opp = GC_arobjfreelist.54 + D.5103;
      D.5104 = pthread_mutex_trylock (&GC_allocate_ml);
      if (D.5104 != 0) goto <D.5105>; else goto <D.5106>;
      <D.5105>:
      GC_lock ();
      <D.5106>:
      op = *opp;
      if (op == 0B) goto <D.5107>; else goto <D.5108>;
      <D.5107>:
      pthread_mutex_unlock (&GC_allocate_ml);
      GC_array_kind.55 = GC_array_kind;
      D.5110 = GC_generic_malloc (lb, GC_array_kind.55);
      op = GC_clear_stack (D.5110);
      if (op == 0B) goto <D.5111>; else goto <D.5112>;
      <D.5111>:
      D.5091 = 0B;
      return D.5091;
      <D.5112>:
      lw = GC_arrays._size_map[lb];
      goto <D.5113>;
      <D.5108>:
      D.5114 = MEM[(char * *)op];
      *opp = D.5114;
      MEM[(char * *)op] = 0B;
      D.5115 = GC_arrays._words_allocd;
      D.5116 = D.5115 + lw;
      GC_arrays._words_allocd = D.5116;
      pthread_mutex_unlock (&GC_allocate_ml);
      <D.5113>:
      goto <D.5117>;
      <D.5101>:
      GC_array_kind.55 = GC_array_kind;
      D.5118 = GC_generic_malloc (lb, GC_array_kind.55);
      op = GC_clear_stack (D.5118);
      if (op == 0B) goto <D.5119>; else goto <D.5120>;
      <D.5119>:
      D.5091 = 0B;
      return D.5091;
      <D.5120>:
      D.5121 = GC_size (op);
      lw = D.5121 >> 2;
      <D.5117>:
      if (descr_type == 1) goto <D.5122>; else goto <D.5123>;
      <D.5122>:
      {
        volatile struct LeafDescriptor * lp;

        D.5124 = lw + 1073741819;
        D.5125 = D.5124 * 4;
        lp = op + D.5125;
        lp->ld_tag = 1;
        D.5126 = leaf.ld_size;
        lp->ld_size = D.5126;
        D.5127 = leaf.ld_nelements;
        lp->ld_nelements = D.5127;
        D.5128 = leaf.ld_descriptor;
        lp->ld_descriptor = D.5128;
        D.5129 = lw + 1073741823;
        D.5130 = D.5129 * 4;
        D.5131 = op + D.5130;
        lp.56 = (long unsigned int) lp;
        *D.5131 = lp.56;
      }
      goto <D.5133>;
      <D.5123>:
      {
        extern unsigned int GC_finalization_failures;
        unsigned int ff;

        ff = GC_finalization_failures;
        D.5129 = lw + 1073741823;
        D.5130 = D.5129 * 4;
        D.5134 = op + D.5130;
        complex_descr.57 = complex_descr;
        complex_descr.58 = (long unsigned int) complex_descr.57;
        *D.5134 = complex_descr.58;
        D.5129 = lw + 1073741823;
        D.5130 = D.5129 * 4;
        D.5137 = op + D.5130;
        GC_general_register_disappearing_link (D.5137, op);
        GC_finalization_failures.59 = GC_finalization_failures;
        if (ff != GC_finalization_failures.59) goto <D.5139>; else goto <D.5140>;
        <D.5139>:
        D.5093 = n * lb;
        D.5091 = GC_malloc (D.5093);
        return D.5091;
        <D.5140>:
      }
      <D.5133>:
      D.5091 = op;
      return D.5091;
    }
  finally
    {
      simple_descr = {CLOBBER};
      complex_descr = {CLOBBER};
      leaf = {CLOBBER};
    }
}