GC_add_ext_descriptor (GC_word * bm, word nbits)
{
  long unsigned int D.5574;
  int D.5575;
  signed_word D.5583;
  long unsigned int D.5584;
  int D.5587;
  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.5597;
  long unsigned int GC_avail_descr.4;
  long unsigned int result.3;
  long unsigned int D.5600;
  long unsigned int D.5601;
  struct ext_descr * D.5602;
  long unsigned int D.5603;
  GC_word * D.5604;
  long unsigned int D.5605;
  long unsigned int D.5606;
  unsigned int D.5607;
  unsigned int D.5608;
  unsigned int D.5609;
  unsigned int D.5610;
  register size_t nwords;
  register signed_word result;
  register word i;
  register word last_part;
  register int extra_bits;

  D.5574 = nbits + 63;
  nwords = D.5574 >> 6;
  D.5575 = GC_test_and_set (&GC_allocate_lock);
  if (D.5575 != 0) goto <D.5576>; else goto <D.5577>;
  <D.5576>:
  GC_lock ();
  <D.5577>:
  goto <D.5397>;
  <D.5396>:
  {
    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.5578>; else goto <D.5579>;
    <D.5578>:
    new_size = 100;
    goto <D.5580>;
    <D.5579>:
    new_size = ed_size * 2;
    if (new_size > 72057594037927935) goto <D.5581>; else goto <D.5582>;
    <D.5581>:
    D.5583 = -1;
    return D.5583;
    <D.5582>:
    <D.5580>:
    D.5584 = new_size * 16;
    new = GC_malloc_atomic (D.5584);
    if (new == 0B) goto <D.5585>; else goto <D.5586>;
    <D.5585>:
    D.5583 = -1;
    return D.5583;
    <D.5586>:
    D.5587 = GC_test_and_set (&GC_allocate_lock);
    if (D.5587 != 0) goto <D.5588>; else goto <D.5589>;
    <D.5588>:
    GC_lock ();
    <D.5589>:
    GC_ed_size.0 = GC_ed_size;
    if (ed_size == GC_ed_size.0) goto <D.5591>; else goto <D.5592>;
    <D.5591>:
    GC_avail_descr.1 = GC_avail_descr;
    if (GC_avail_descr.1 != 0) goto <D.5594>; else goto <D.5595>;
    <D.5594>:
    GC_ext_descriptors.2 = GC_ext_descriptors;
    GC_avail_descr.1 = GC_avail_descr;
    D.5597 = GC_avail_descr.1 * 16;
    memcpy (new, GC_ext_descriptors.2, D.5597);
    <D.5595>:
    GC_ed_size = new_size;
    GC_ext_descriptors = new;
    <D.5592>:
  }
  <D.5397>:
  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.5396>; else goto <D.5398>;
  <D.5398>:
  GC_avail_descr.1 = GC_avail_descr;
  result = (signed_word) GC_avail_descr.1;
  i = 0;
  goto <D.5400>;
  <D.5399>:
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.5600 = result.3 + i;
  D.5601 = D.5600 * 16;
  D.5602 = GC_ext_descriptors.2 + D.5601;
  D.5603 = i * 8;
  D.5604 = bm + D.5603;
  D.5605 = *D.5604;
  D.5602->ed_bitmap = D.5605;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.5600 = result.3 + i;
  D.5601 = D.5600 * 16;
  D.5602 = GC_ext_descriptors.2 + D.5601;
  D.5602->ed_continued = 1;
  i = i + 1;
  <D.5400>:
  D.5606 = nwords + 18446744073709551615;
  if (D.5606 > i) goto <D.5399>; else goto <D.5401>;
  <D.5401>:
  D.5603 = i * 8;
  D.5604 = bm + D.5603;
  last_part = *D.5604;
  D.5607 = (unsigned int) nwords;
  D.5608 = D.5607 * 64;
  D.5609 = (unsigned int) nbits;
  D.5610 = D.5608 - D.5609;
  extra_bits = (int) D.5610;
  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.5600 = result.3 + i;
  D.5601 = D.5600 * 16;
  D.5602 = GC_ext_descriptors.2 + D.5601;
  D.5602->ed_bitmap = last_part;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.5600 = result.3 + i;
  D.5601 = D.5600 * 16;
  D.5602 = GC_ext_descriptors.2 + D.5601;
  D.5602->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.5583 = result;
  return D.5583;
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.5612;
  int oldval;
  int temp;

  temp = 1;
  __asm__ __volatile__("1:	lwarx %0,0,%1
	cmpwi %0, 0
	bne 2f
	stwcx. %2,0,%1
	bne- 1b
	sync
2:	
" : "=&r" oldval : "r" addr, "r" temp : "memory", "cr0");
  D.5612 = oldval;
  return D.5612;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.5614;
  long unsigned int D.5615;

  D.5615 = __builtin_object_size (__dest, 0);
  D.5614 = __builtin___memcpy_chk (__dest, __src, __len, D.5615);
  return D.5614;
}


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


GC_double_descr (GC_descr descriptor, word nwords)
{
  long unsigned int D.5617;
  long unsigned int D.5620;
  long unsigned int D.5621;
  int D.5622;
  long unsigned int D.5623;
  GC_descr D.5624;

  D.5617 = descriptor & 3;
  if (D.5617 == 0) goto <D.5618>; else goto <D.5619>;
  <D.5618>:
  D.5620 = descriptor >> 3;
  descriptor = GC_bm_table[D.5620];
  <D.5619>:
  D.5621 = descriptor & 18446744073709551612;
  D.5622 = (int) nwords;
  D.5623 = D.5621 >> D.5622;
  descriptor = D.5623 | descriptor;
  D.5624 = descriptor;
  return D.5624;
}


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.5626;
  long unsigned int D.5631;
  int D.5632;
  long unsigned int D.5646;
  long unsigned int D.5649;
  long unsigned int D.5650;
  long unsigned int D.5651;
  long unsigned int D.5652;
  long unsigned int D.5653;
  long unsigned int D.5661;
  union complex_descriptor * D.5662;
  long unsigned int D.5665;
  long unsigned int D.5666;
  long unsigned int D.5667;
  union complex_descriptor * D.5668;
  union complex_descriptor * D.5669;
  union complex_descriptor * D.5670;

  D.5626 = descriptor & 3;
  if (D.5626 == 0) goto <D.5627>; else goto <D.5628>;
  <D.5627>:
  if (descriptor == size) goto <D.5629>; else goto <D.5630>;
  <D.5629>:
  D.5631 = nelements * descriptor;
  *simple_d = D.5631;
  D.5632 = 0;
  return D.5632;
  <D.5630>:
  if (descriptor == 0) goto <D.5633>; else goto <D.5634>;
  <D.5633>:
  *simple_d = 0;
  D.5632 = 0;
  return D.5632;
  <D.5634>:
  <D.5628>:
  if (nelements <= 50) goto <D.5635>; else goto <D.5636>;
  <D.5635>:
  if (nelements <= 1) goto <D.5637>; else goto <D.5638>;
  <D.5637>:
  if (nelements == 1) goto <D.5639>; else goto <D.5640>;
  <D.5639>:
  *simple_d = descriptor;
  D.5632 = 0;
  return D.5632;
  <D.5640>:
  *simple_d = 0;
  D.5632 = 0;
  return D.5632;
  <D.5638>:
  goto <D.5641>;
  <D.5636>:
  if (size <= 31) goto <D.5642>; else goto <D.5643>;
  <D.5642>:
  D.5626 = descriptor & 3;
  if (D.5626 != 2) goto <D.5644>; else goto <D.5645>;
  <D.5644>:
  D.5646 = size & 7;
  if (D.5646 == 0) goto <D.5647>; else goto <D.5648>;
  <D.5647>:
  {
    int result;

    D.5649 = nelements / 2;
    D.5650 = size * 2;
    D.5651 = size >> 3;
    D.5652 = GC_double_descr (descriptor, D.5651);
    result = GC_make_array_descriptor (D.5649, D.5650, D.5652, simple_d, complex_d, leaf);
    D.5653 = nelements & 1;
    if (D.5653 == 0) goto <D.5654>; else goto <D.5655>;
    <D.5654>:
    D.5632 = result;
    return D.5632;
    <D.5655>:
    {
      struct LeafDescriptor * one_element;

      one_element = GC_malloc_atomic (32);
      if (result == -1) goto <D.5656>; else goto <D.5658>;
      <D.5658>:
      if (one_element == 0B) goto <D.5656>; else goto <D.5657>;
      <D.5656>:
      D.5632 = -1;
      return D.5632;
      <D.5657>:
      one_element->ld_tag = 1;
      one_element->ld_size = size;
      one_element->ld_nelements = 1;
      one_element->ld_descriptor = descriptor;
      switch (result) <default: <D.5671>, case 0: <D.5418>, case 1: <D.5421>, case 2: <D.5423>>
      <D.5418>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (32);
        if (beginning == 0B) goto <D.5659>; else goto <D.5660>;
        <D.5659>:
        D.5632 = -1;
        return D.5632;
        <D.5660>:
        beginning->ld_tag = 1;
        beginning->ld_size = size;
        beginning->ld_nelements = 1;
        D.5661 = *simple_d;
        beginning->ld_descriptor = D.5661;
        D.5662 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.5662;
        goto <D.5420>;
      }
      <D.5421>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (32);
        if (beginning == 0B) goto <D.5663>; else goto <D.5664>;
        <D.5663>:
        D.5632 = -1;
        return D.5632;
        <D.5664>:
        beginning->ld_tag = 1;
        D.5665 = leaf->ld_size;
        beginning->ld_size = D.5665;
        D.5666 = leaf->ld_nelements;
        beginning->ld_nelements = D.5666;
        D.5667 = leaf->ld_descriptor;
        beginning->ld_descriptor = D.5667;
        D.5668 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.5668;
        goto <D.5420>;
      }
      <D.5423>:
      D.5669 = *complex_d;
      D.5670 = GC_make_sequence_descriptor (D.5669, one_element);
      *complex_d = D.5670;
      goto <D.5420>;
      <D.5671>:
      <D.5420>:
      D.5632 = 2;
      return D.5632;
    }
  }
  <D.5648>:
  <D.5645>:
  <D.5643>:
  <D.5641>:
  leaf->ld_size = size;
  leaf->ld_nelements = nelements;
  leaf->ld_descriptor = descriptor;
  D.5632 = 1;
  return D.5632;
}


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

  result = GC_malloc (24);
  if (result != 0B) goto <D.5673>; else goto <D.5674>;
  <D.5673>:
  result->sd_tag = 3;
  result->sd_first = first;
  result->sd_second = second;
  <D.5674>:
  D.5675 = result;
  return D.5675;
}


GC_init_explicit_typing ()
{
  int D.5677;
  int GC_explicit_typing_initialized.5;
  void * * GC_eobjfreelist.6;
  char * * GC_eobjfreelist.7;
  int GC_explicit_kind.8;
  int GC_typed_mark_proc_index.9;
  void * * GC_arobjfreelist.10;
  int GC_array_mark_proc_index.11;
  char * * GC_arobjfreelist.12;
  int GC_array_mark_proc_index.13;
  int D.5691;
  int D.5692;
  long unsigned int D.5693;
  int GC_array_kind.14;
  unsigned int i.15;
  unsigned int D.5696;
  int D.5697;
  long unsigned int D.5698;
  unsigned int i.16;
  register int i;

  D.5677 = GC_test_and_set (&GC_allocate_lock);
  if (D.5677 != 0) goto <D.5678>; else goto <D.5679>;
  <D.5678>:
  GC_lock ();
  <D.5679>:
  GC_explicit_typing_initialized.5 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.5 != 0) goto <D.5681>; else goto <D.5682>;
  <D.5681>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.5682>:
  GC_explicit_typing_initialized = 1;
  GC_eobjfreelist.6 = GC_new_free_list_inner ();
  GC_eobjfreelist = GC_eobjfreelist.6;
  GC_eobjfreelist.7 = GC_eobjfreelist;
  GC_explicit_kind.8 = GC_new_kind_inner (GC_eobjfreelist.7, 18446744073709551611, 1, 1);
  GC_explicit_kind = GC_explicit_kind.8;
  GC_typed_mark_proc_index.9 = GC_new_proc_inner (GC_typed_mark_proc);
  GC_typed_mark_proc_index = GC_typed_mark_proc_index.9;
  GC_arobjfreelist.10 = GC_new_free_list_inner ();
  GC_arobjfreelist = GC_arobjfreelist.10;
  GC_array_mark_proc_index.11 = GC_new_proc_inner (GC_array_mark_proc);
  GC_array_mark_proc_index = GC_array_mark_proc_index.11;
  GC_arobjfreelist.12 = GC_arobjfreelist;
  GC_array_mark_proc_index.13 = GC_array_mark_proc_index;
  D.5691 = GC_array_mark_proc_index.13 << 2;
  D.5692 = D.5691 | 2;
  D.5693 = (long unsigned int) D.5692;
  GC_array_kind.14 = GC_new_kind_inner (GC_arobjfreelist.12, D.5693, 0, 1);
  GC_array_kind = GC_array_kind.14;
  i = 0;
  goto <D.5446>;
  <D.5445>:
  {
    GC_descr d;

    i.15 = (unsigned int) i;
    D.5696 = 64 - i.15;
    D.5697 = (int) D.5696;
    D.5698 = 18446744073709551615 >> D.5697;
    i.15 = (unsigned int) i;
    D.5696 = 64 - i.15;
    D.5697 = (int) D.5696;
    d = D.5698 << D.5697;
    d = d | 1;
    GC_bm_table[i] = d;
  }
  i = i + 1;
  <D.5446>:
  i.16 = (unsigned int) i;
  if (i.16 <= 31) goto <D.5445>; else goto <D.5447>;
  <D.5447>:
  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.5702;
  struct ext_descr * D.5703;
  long unsigned int D.5704;
  char * current.18;
  long unsigned int my_current.19;
  long unsigned int D.5713;
  long unsigned int D.5714;
  struct bottom_index * D.5716;
  long unsigned int D.5717;
  long unsigned int D.5718;
  long unsigned int my_hhdr.20;
  struct hdr * GC_invalid_header.21;
  long int my_current.22;
  int D.5724;
  map_entry_type * D.5725;
  sizetype D.5726;
  map_entry_type * D.5727;
  unsigned char D.5728;
  long unsigned int D.5733;
  long unsigned int D.5734;
  long unsigned int D.5735;
  long unsigned int D.5736;
  int GC_all_interior_pointers.23;
  int D.5748;
  sizetype D.5749;
  int D.5750;
  long unsigned int D.5751;
  long unsigned int D.5753;
  long unsigned int D.5759;
  long unsigned int D.5760;
  sizetype my_current.24;
  sizetype D.5762;
  sizetype D.5763;
  GC_word * D.5764;
  int D.5765;
  GC_word * D.5770;
  long unsigned int D.5771;
  long unsigned int D.5772;
  int GC_typed_mark_proc_index.25;
  long unsigned int D.5774;
  long unsigned int D.5775;
  long unsigned int D.5776;
  long unsigned int D.5777;
  struct mse * D.5778;
  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.5702 = env * 16;
  D.5703 = GC_ext_descriptors.17 + D.5702;
  bm = D.5703->ed_bitmap;
  current_p = addr;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  goto <D.5477>;
  <D.5476>:
  D.5704 = bm & 1;
  if (D.5704 != 0) goto <D.5705>; else goto <D.5706>;
  <D.5705>:
  current = *current_p;
  current.18 = (char *) current;
  if (current.18 >= least_ha) goto <D.5708>; else goto <D.5709>;
  <D.5708>:
  current.18 = (char *) current;
  if (current.18 <= greatest_ha) goto <D.5710>; else goto <D.5711>;
  <D.5710>:
  {
    struct hdr * my_hhdr;
    char * my_current;

    my_current = (char *) current;
    {
      register struct hdr * * _ha;

      {
        register struct bottom_index * bi;

        {
          register word hi;
          register struct bottom_index * _bi;

          my_current.19 = (long unsigned int) my_current;
          hi = my_current.19 >> 22;
          D.5713 = hi & 2047;
          _bi = GC_arrays._top_index[D.5713];
          goto <D.5466>;
          <D.5465>:
          _bi = _bi->hash_link;
          <D.5466>:
          D.5714 = _bi->key;
          if (D.5714 != hi) goto <D.5715>; else goto <D.5467>;
          <D.5715>:
          D.5716 = GC_arrays._all_nils;
          if (D.5716 != _bi) goto <D.5465>; else goto <D.5467>;
          <D.5467>:
          bi = _bi;
        }
        my_current.19 = (long unsigned int) my_current;
        D.5717 = my_current.19 >> 12;
        D.5718 = D.5717 & 1023;
        _ha = &bi->index[D.5718];
      }
      my_hhdr = *_ha;
    }
    my_hhdr.20 = (long unsigned int) my_hhdr;
    if (my_hhdr.20 <= 4095) goto <D.5720>; else goto <D.5721>;
    <D.5720>:
    {
      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.5721>:
    {
      int displ;
      int map_entry;

      my_current.22 = (long int) my_current;
      D.5724 = (int) my_current.22;
      displ = D.5724 & 4095;
      D.5725 = my_hhdr->hb_map;
      D.5726 = (sizetype) displ;
      D.5727 = D.5725 + D.5726;
      D.5728 = *D.5727;
      map_entry = (int) D.5728;
      displ = displ >> 3;
      if (map_entry > 253) goto <D.5729>; else goto <D.5730>;
      <D.5729>:
      if (map_entry == 254) goto <D.5731>; else goto <D.5732>;
      <D.5731>:
      D.5733 = (long unsigned int) displ;
      D.5734 = my_hhdr->hb_sz;
      D.5735 = D.5733 % D.5734;
      map_entry = (int) D.5735;
      displ = displ - map_entry;
      D.5733 = (long unsigned int) displ;
      D.5734 = my_hhdr->hb_sz;
      D.5736 = D.5733 + D.5734;
      if (D.5736 > 512) goto <D.5737>; else goto <D.5738>;
      <D.5737>:
      GC_all_interior_pointers.23 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.23 != 0) goto <D.5740>; else goto <D.5741>;
      <D.5740>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.19);
      goto <D.5742>;
      <D.5741>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.19);
      <D.5742>:
      goto exit1;
      <D.5738>:
      goto <D.5743>;
      <D.5732>:
      GC_all_interior_pointers.23 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.23 != 0) goto <D.5744>; else goto <D.5745>;
      <D.5744>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.19);
      goto <D.5746>;
      <D.5745>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.19);
      <D.5746>:
      goto exit1;
      <D.5743>:
      goto <D.5747>;
      <D.5730>:
      displ = displ - map_entry;
      <D.5747>:
      {
        register word * mark_word_addr;

        D.5748 = displ >> 6;
        D.5749 = (sizetype) D.5748;
        mark_word_addr = &my_hhdr->hb_marks[D.5749];
        {
          word old;
          word my_bits;

          old = *mark_word_addr;
          D.5750 = displ & 63;
          my_bits = 1 << D.5750;
          D.5751 = old & my_bits;
          if (D.5751 != 0) goto exit1; else goto <D.5752>;
          <D.5752>:
          D.5753 = old | my_bits;
          *mark_word_addr = D.5753;
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.5754>; else goto <D.5755>;
        <D.5754>:
        goto <D.5756>;
        <D.5755>:
        mark_stack_ptr = mark_stack_ptr + 16;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.5757>; else goto <D.5758>;
        <D.5757>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.5758>:
        D.5759 = (long unsigned int) displ;
        D.5760 = D.5759 * 8;
        my_current.24 = (sizetype) my_current;
        D.5762 = my_current.24 & 18446744073709547520;
        D.5763 = D.5760 + D.5762;
        D.5764 = (GC_word *) D.5763;
        mark_stack_ptr->mse_start = D.5764;
        mark_stack_ptr->mse_descr = _descr;
        <D.5756>:
      }
    }
    exit1:
  }
  <D.5711>:
  <D.5709>:
  <D.5706>:
  bm = bm >> 1;
  current_p = current_p + 8;
  <D.5477>:
  if (bm != 0) goto <D.5476>; else goto <D.5478>;
  <D.5478>:
  GC_ext_descriptors.17 = GC_ext_descriptors;
  D.5702 = env * 16;
  D.5703 = GC_ext_descriptors.17 + D.5702;
  D.5765 = D.5703->ed_continued;
  if (D.5765 != 0) goto <D.5766>; else goto <D.5767>;
  <D.5766>:
  mark_stack_ptr = mark_stack_ptr + 16;
  if (mark_stack_ptr >= mark_stack_limit) goto <D.5768>; else goto <D.5769>;
  <D.5768>:
  mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
  <D.5769>:
  D.5770 = addr + 512;
  mark_stack_ptr->mse_start = D.5770;
  D.5771 = env + 1;
  D.5772 = D.5771 << 6;
  GC_typed_mark_proc_index.25 = GC_typed_mark_proc_index;
  D.5774 = (long unsigned int) GC_typed_mark_proc_index.25;
  D.5775 = D.5772 | D.5774;
  D.5776 = D.5775 << 2;
  D.5777 = D.5776 | 2;
  mark_stack_ptr->mse_descr = D.5777;
  <D.5767>:
  D.5778 = mark_stack_ptr;
  return D.5778;
}


GC_descr_obj_size (union complex_descriptor * d)
{
  long unsigned int D.5780;
  word D.5781;
  long unsigned int D.5782;
  long unsigned int D.5783;
  long unsigned int D.5784;
  union ComplexDescriptor * D.5785;
  long unsigned int D.5786;
  union ComplexDescriptor * D.5787;
  long unsigned int D.5788;
  union ComplexDescriptor * D.5789;
  long unsigned int D.5790;

  D.5780 = d->ld.ld_tag;
  switch (D.5780) <default: <D.5485>, case 1: <D.5482>, case 2: <D.5483>, case 3: <D.5484>>
  <D.5482>:
  D.5782 = d->ld.ld_nelements;
  D.5783 = d->ld.ld_size;
  D.5781 = D.5782 * D.5783;
  return D.5781;
  <D.5483>:
  D.5784 = d->ad.ad_nelements;
  D.5785 = d->ad.ad_element_descr;
  D.5786 = GC_descr_obj_size (D.5785);
  D.5781 = D.5784 * D.5786;
  return D.5781;
  <D.5484>:
  D.5787 = d->sd.sd_first;
  D.5788 = GC_descr_obj_size (D.5787);
  D.5789 = d->sd.sd_second;
  D.5790 = GC_descr_obj_size (D.5789);
  D.5781 = D.5788 + D.5790;
  return D.5781;
  <D.5485>:
  GC_abort ("Bad complex descriptor");
  D.5781 = 0;
  return D.5781;
}


GC_push_complex_descriptor (word * addr, union complex_descriptor * d, struct mse * msp, struct mse * msl)
{
  long unsigned int D.5792;
  long int msl.26;
  long int msp.27;
  long int D.5795;
  long int D.5796;
  long int nelements.28;
  struct mse * D.5800;
  union ComplexDescriptor * D.5803;
  union ComplexDescriptor * D.5806;
  register char * current;
  register word nelements;
  register word sz;
  register word i;

  current = addr;
  D.5792 = d->ld.ld_tag;
  switch (D.5792) <default: <D.5507>, case 1: <D.5496>, case 2: <D.5501>, case 3: <D.5506>>
  <D.5496>:
  {
    register GC_descr descr;

    descr = d->ld.ld_descriptor;
    nelements = d->ld.ld_nelements;
    msl.26 = (long int) msl;
    msp.27 = (long int) msp;
    D.5795 = msl.26 - msp.27;
    D.5796 = D.5795 /[ex] 16;
    nelements.28 = (long int) nelements;
    if (D.5796 <= nelements.28) goto <D.5798>; else goto <D.5799>;
    <D.5798>:
    D.5800 = 0B;
    return D.5800;
    <D.5799>:
    sz = d->ld.ld_size;
    i = 0;
    goto <D.5499>;
    <D.5498>:
    msp = msp + 16;
    msp->mse_start = current;
    msp->mse_descr = descr;
    current = current + sz;
    i = i + 1;
    <D.5499>:
    if (i < nelements) goto <D.5498>; else goto <D.5500>;
    <D.5500>:
    D.5800 = msp;
    return D.5800;
  }
  <D.5501>:
  {
    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.5504>;
    <D.5503>:
    msp = GC_push_complex_descriptor (current, descr, msp, msl);
    if (msp == 0B) goto <D.5801>; else goto <D.5802>;
    <D.5801>:
    D.5800 = 0B;
    return D.5800;
    <D.5802>:
    current = current + sz;
    i = i + 1;
    <D.5504>:
    if (i < nelements) goto <D.5503>; else goto <D.5505>;
    <D.5505>:
    D.5800 = msp;
    return D.5800;
  }
  <D.5506>:
  D.5803 = d->sd.sd_first;
  sz = GC_descr_obj_size (D.5803);
  D.5803 = d->sd.sd_first;
  msp = GC_push_complex_descriptor (current, D.5803, msp, msl);
  if (msp == 0B) goto <D.5804>; else goto <D.5805>;
  <D.5804>:
  D.5800 = 0B;
  return D.5800;
  <D.5805>:
  current = current + sz;
  D.5806 = d->sd.sd_second;
  msp = GC_push_complex_descriptor (current, D.5806, msp, msl);
  D.5800 = msp;
  return D.5800;
  <D.5507>:
  GC_abort ("Bad complex descriptor");
  D.5800 = 0B;
  return D.5800;
}


GC_array_mark_proc (word * addr, struct mse * mark_stack_ptr, struct mse * mark_stack_limit, word env)
{
  long unsigned int D.5808;
  sizetype D.5809;
  word * D.5810;
  long unsigned int D.5811;
  struct mse * D.5814;
  struct mse * D.5815;
  long unsigned int D.5818;
  register struct hdr * hhdr;
  register word sz;
  register union complex_descriptor * descr;
  struct mse * orig_mark_stack_ptr;
  struct mse * new_mark_stack_ptr;

  hhdr = GC_find_header (addr);
  sz = hhdr->hb_sz;
  D.5808 = sz * 8;
  D.5809 = D.5808 + 18446744073709551608;
  D.5810 = addr + D.5809;
  D.5811 = *D.5810;
  descr = (union complex_descriptor *) D.5811;
  orig_mark_stack_ptr = mark_stack_ptr;
  if (descr == 0B) goto <D.5812>; else goto <D.5813>;
  <D.5812>:
  D.5814 = orig_mark_stack_ptr;
  return D.5814;
  <D.5813>:
  D.5815 = mark_stack_limit + 18446744073709551600;
  new_mark_stack_ptr = GC_push_complex_descriptor (addr, descr, mark_stack_ptr, D.5815);
  if (new_mark_stack_ptr == 0B) goto <D.5816>; else goto <D.5817>;
  <D.5816>:
  GC_mark_stack_too_small = 1;
  new_mark_stack_ptr = orig_mark_stack_ptr + 16;
  new_mark_stack_ptr->mse_start = addr;
  D.5818 = sz << 3;
  new_mark_stack_ptr->mse_descr = D.5818;
  goto <D.5819>;
  <D.5817>:
  new_mark_stack_ptr = new_mark_stack_ptr + 16;
  D.5808 = sz * 8;
  D.5809 = D.5808 + 18446744073709551608;
  D.5810 = addr + D.5809;
  new_mark_stack_ptr->mse_start = D.5810;
  new_mark_stack_ptr->mse_descr = 8;
  <D.5819>:
  D.5814 = new_mark_stack_ptr;
  return D.5814;
}


GC_make_descriptor (GC_word * bm, size_t len)
{
  long unsigned int D.5821;
  int GC_explicit_typing_initialized.29;
  long unsigned int last_set_bit.30;
  long unsigned int D.5827;
  long unsigned int D.5828;
  GC_word * D.5829;
  long unsigned int D.5830;
  int D.5831;
  int D.5832;
  long unsigned int D.5833;
  long unsigned int D.5834;
  GC_descr D.5837;
  long unsigned int D.5838;
  long unsigned int D.5839;
  long unsigned int D.5840;
  GC_word * D.5841;
  long unsigned int D.5842;
  int D.5843;
  long unsigned int D.5844;
  long unsigned int D.5845;
  long int D.5848;
  long int D.5851;
  long int D.5852;
  unsigned int D.5855;
  unsigned int D.5856;
  long unsigned int D.5859;
  long unsigned int index.31;
  long unsigned int D.5863;
  int GC_typed_mark_proc_index.32;
  long unsigned int D.5865;
  long unsigned int D.5866;
  long unsigned int D.5867;
  register signed_word last_set_bit;
  register word result;
  register int i;

  D.5821 = len + 18446744073709551615;
  last_set_bit = (signed_word) D.5821;
  GC_explicit_typing_initialized.29 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.29 == 0) goto <D.5823>; else goto <D.5824>;
  <D.5823>:
  GC_init_explicit_typing ();
  <D.5824>:
  goto <D.5527>;
  <D.5526>:
  last_set_bit = last_set_bit + -1;
  <D.5527>:
  if (last_set_bit >= 0) goto <D.5825>; else goto <D.5528>;
  <D.5825>:
  last_set_bit.30 = (long unsigned int) last_set_bit;
  D.5827 = last_set_bit.30 / 64;
  D.5828 = D.5827 * 8;
  D.5829 = bm + D.5828;
  D.5830 = *D.5829;
  D.5831 = (int) last_set_bit;
  D.5832 = D.5831 & 63;
  D.5833 = D.5830 >> D.5832;
  D.5834 = D.5833 & 1;
  if (D.5834 == 0) goto <D.5526>; else goto <D.5528>;
  <D.5528>:
  if (last_set_bit < 0) goto <D.5835>; else goto <D.5836>;
  <D.5835>:
  D.5837 = 0;
  return D.5837;
  <D.5836>:
  {
    register GC_bool all_bits_set;

    all_bits_set = 1;
    i = 0;
    goto <D.5532>;
    <D.5531>:
    D.5838 = (long unsigned int) i;
    D.5839 = D.5838 / 64;
    D.5840 = D.5839 * 8;
    D.5841 = bm + D.5840;
    D.5842 = *D.5841;
    D.5843 = i & 63;
    D.5844 = D.5842 >> D.5843;
    D.5845 = D.5844 & 1;
    if (D.5845 == 0) goto <D.5846>; else goto <D.5847>;
    <D.5846>:
    all_bits_set = 0;
    goto <D.5530>;
    <D.5847>:
    i = i + 1;
    <D.5532>:
    D.5848 = (long int) i;
    if (D.5848 < last_set_bit) goto <D.5531>; else goto <D.5530>;
    <D.5530>:
    if (all_bits_set != 0) goto <D.5849>; else goto <D.5850>;
    <D.5849>:
    D.5851 = last_set_bit + 1;
    D.5852 = D.5851 << 3;
    D.5837 = (GC_descr) D.5852;
    return D.5837;
    <D.5850>:
  }
  last_set_bit.30 = (long unsigned int) last_set_bit;
  if (last_set_bit.30 <= 61) goto <D.5853>; else goto <D.5854>;
  <D.5853>:
  result = 9223372036854775808;
  D.5855 = (unsigned int) last_set_bit;
  D.5856 = D.5855 + 4294967295;
  i = (int) D.5856;
  goto <D.5534>;
  <D.5533>:
  result = result >> 1;
  D.5838 = (long unsigned int) i;
  D.5839 = D.5838 / 64;
  D.5840 = D.5839 * 8;
  D.5841 = bm + D.5840;
  D.5842 = *D.5841;
  D.5843 = i & 63;
  D.5844 = D.5842 >> D.5843;
  D.5845 = D.5844 & 1;
  if (D.5845 != 0) goto <D.5857>; else goto <D.5858>;
  <D.5857>:
  result = result | 9223372036854775808;
  <D.5858>:
  i = i + -1;
  <D.5534>:
  if (i >= 0) goto <D.5533>; else goto <D.5535>;
  <D.5535>:
  result = result | 1;
  D.5837 = result;
  return D.5837;
  <D.5854>:
  {
    signed_word index;

    last_set_bit.30 = (long unsigned int) last_set_bit;
    D.5859 = last_set_bit.30 + 1;
    index = GC_add_ext_descriptor (bm, D.5859);
    if (index == -1) goto <D.5860>; else goto <D.5861>;
    <D.5860>:
    D.5851 = last_set_bit + 1;
    D.5852 = D.5851 << 3;
    D.5837 = (GC_descr) D.5852;
    return D.5837;
    <D.5861>:
    index.31 = (long unsigned int) index;
    D.5863 = index.31 << 6;
    GC_typed_mark_proc_index.32 = GC_typed_mark_proc_index;
    D.5865 = (long unsigned int) GC_typed_mark_proc_index.32;
    D.5866 = D.5863 | D.5865;
    D.5867 = D.5866 << 2;
    result = D.5867 | 2;
    D.5837 = result;
    return D.5837;
  }
}


GC_malloc_explicitly_typed (size_t lb, GC_descr d)
{
  int GC_all_interior_pointers.33;
  long unsigned int D.5870;
  long unsigned int D.5871;
  long unsigned int D.5872;
  unsigned int D.5875;
  char * * GC_eobjfreelist.34;
  long unsigned int D.5877;
  int D.5878;
  int GC_explicit_kind.35;
  char * D.5884;
  void * D.5887;
  char * D.5889;
  long unsigned int D.5890;
  long unsigned int D.5891;
  char * D.5893;
  long unsigned int D.5896;
  sizetype D.5899;
  word * D.5900;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.33 = GC_all_interior_pointers;
  D.5870 = (long unsigned int) GC_all_interior_pointers.33;
  D.5871 = lb - D.5870;
  lb = D.5871 + 8;
  GC_all_interior_pointers.33 = GC_all_interior_pointers;
  D.5870 = (long unsigned int) GC_all_interior_pointers.33;
  D.5872 = 2048 - D.5870;
  if (D.5872 >= lb) goto <D.5873>; else goto <D.5874>;
  <D.5873>:
  D.5875 = GC_arrays._size_map[lb];
  lw = (word) D.5875;
  GC_eobjfreelist.34 = GC_eobjfreelist;
  D.5877 = lw * 8;
  opp = GC_eobjfreelist.34 + D.5877;
  D.5878 = GC_test_and_set (&GC_allocate_lock);
  if (D.5878 != 0) goto <D.5879>; else goto <D.5880>;
  <D.5879>:
  GC_lock ();
  <D.5880>:
  op = *opp;
  if (op == 0B) goto <D.5881>; else goto <D.5882>;
  <D.5881>:
  GC_clear (&GC_allocate_lock);
  GC_explicit_kind.35 = GC_explicit_kind;
  D.5884 = GC_generic_malloc (lb, GC_explicit_kind.35);
  op = GC_clear_stack (D.5884);
  if (op == 0B) goto <D.5885>; else goto <D.5886>;
  <D.5885>:
  D.5887 = 0B;
  return D.5887;
  <D.5886>:
  D.5875 = GC_arrays._size_map[lb];
  lw = (word) D.5875;
  goto <D.5888>;
  <D.5882>:
  D.5889 = MEM[(char * *)op];
  *opp = D.5889;
  MEM[(char * *)op] = 0B;
  D.5890 = GC_arrays._words_allocd;
  D.5891 = D.5890 + lw;
  GC_arrays._words_allocd = D.5891;
  GC_clear (&GC_allocate_lock);
  <D.5888>:
  goto <D.5892>;
  <D.5874>:
  GC_explicit_kind.35 = GC_explicit_kind;
  D.5893 = GC_generic_malloc (lb, GC_explicit_kind.35);
  op = GC_clear_stack (D.5893);
  if (op != 0B) goto <D.5894>; else goto <D.5895>;
  <D.5894>:
  D.5896 = GC_size (op);
  lw = D.5896 >> 3;
  <D.5895>:
  <D.5892>:
  if (op != 0B) goto <D.5897>; else goto <D.5898>;
  <D.5897>:
  D.5877 = lw * 8;
  D.5899 = D.5877 + 18446744073709551608;
  D.5900 = op + D.5899;
  *D.5900 = d;
  <D.5898>:
  D.5887 = op;
  return D.5887;
}


GC_malloc_explicitly_typed_ignore_off_page (size_t lb, GC_descr d)
{
  int GC_all_interior_pointers.36;
  long unsigned int D.5903;
  long unsigned int D.5904;
  long unsigned int D.5905;
  unsigned int D.5908;
  char * * GC_eobjfreelist.37;
  long unsigned int D.5910;
  int D.5911;
  int GC_explicit_kind.38;
  char * D.5917;
  char * D.5919;
  long unsigned int D.5920;
  long unsigned int D.5921;
  char * D.5923;
  long unsigned int D.5926;
  sizetype D.5929;
  word * D.5930;
  void * D.5931;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.36 = GC_all_interior_pointers;
  D.5903 = (long unsigned int) GC_all_interior_pointers.36;
  D.5904 = lb - D.5903;
  lb = D.5904 + 8;
  GC_all_interior_pointers.36 = GC_all_interior_pointers;
  D.5903 = (long unsigned int) GC_all_interior_pointers.36;
  D.5905 = 2048 - D.5903;
  if (D.5905 >= lb) goto <D.5906>; else goto <D.5907>;
  <D.5906>:
  D.5908 = GC_arrays._size_map[lb];
  lw = (word) D.5908;
  GC_eobjfreelist.37 = GC_eobjfreelist;
  D.5910 = lw * 8;
  opp = GC_eobjfreelist.37 + D.5910;
  D.5911 = GC_test_and_set (&GC_allocate_lock);
  if (D.5911 != 0) goto <D.5912>; else goto <D.5913>;
  <D.5912>:
  GC_lock ();
  <D.5913>:
  op = *opp;
  if (op == 0B) goto <D.5914>; else goto <D.5915>;
  <D.5914>:
  GC_clear (&GC_allocate_lock);
  GC_explicit_kind.38 = GC_explicit_kind;
  D.5917 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.38);
  op = GC_clear_stack (D.5917);
  D.5908 = GC_arrays._size_map[lb];
  lw = (word) D.5908;
  goto <D.5918>;
  <D.5915>:
  D.5919 = MEM[(char * *)op];
  *opp = D.5919;
  MEM[(char * *)op] = 0B;
  D.5920 = GC_arrays._words_allocd;
  D.5921 = D.5920 + lw;
  GC_arrays._words_allocd = D.5921;
  GC_clear (&GC_allocate_lock);
  <D.5918>:
  goto <D.5922>;
  <D.5907>:
  GC_explicit_kind.38 = GC_explicit_kind;
  D.5923 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.38);
  op = GC_clear_stack (D.5923);
  if (op != 0B) goto <D.5924>; else goto <D.5925>;
  <D.5924>:
  D.5926 = GC_size (op);
  lw = D.5926 >> 3;
  <D.5925>:
  <D.5922>:
  if (op != 0B) goto <D.5927>; else goto <D.5928>;
  <D.5927>:
  D.5910 = lw * 8;
  D.5929 = D.5910 + 18446744073709551608;
  D.5930 = op + D.5929;
  *D.5930 = d;
  <D.5928>:
  D.5931 = op;
  return D.5931;
}


GC_calloc_explicitly_typed (size_t n, size_t lb, GC_descr d)
{
  void * D.5933;
  long unsigned int D.5934;
  long unsigned int simple_descr.39;
  int GC_all_interior_pointers.40;
  long unsigned int D.5937;
  long unsigned int D.5938;
  long unsigned int D.5940;
  unsigned int D.5943;
  char * * GC_arobjfreelist.41;
  long unsigned int D.5945;
  int D.5946;
  int GC_array_kind.42;
  char * D.5952;
  char * D.5956;
  long unsigned int D.5957;
  long unsigned int D.5958;
  char * D.5960;
  long unsigned int D.5963;
  sizetype D.5966;
  long unsigned int D.5967;
  long unsigned int D.5968;
  long unsigned int D.5969;
  sizetype D.5970;
  volatile word * D.5971;
  long unsigned int lp.43;
  word * D.5974;
  union complex_descriptor * complex_descr.44;
  long unsigned int complex_descr.45;
  void * * D.5977;
  unsigned int GC_finalization_failures.46;
  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.5939>, case -1: <D.5564>, case 0: <D.5565>, case 1: <D.5566>, case 2: <D.5568>>
      <D.5564>:
      D.5933 = 0B;
      return D.5933;
      <D.5565>:
      D.5934 = n * lb;
      simple_descr.39 = simple_descr;
      D.5933 = GC_malloc_explicitly_typed (D.5934, simple_descr.39);
      return D.5933;
      <D.5566>:
      lb = lb * n;
      GC_all_interior_pointers.40 = GC_all_interior_pointers;
      D.5937 = (long unsigned int) GC_all_interior_pointers.40;
      D.5938 = lb - D.5937;
      lb = D.5938 + 40;
      goto <D.5567>;
      <D.5568>:
      lb = lb * n;
      GC_all_interior_pointers.40 = GC_all_interior_pointers;
      D.5937 = (long unsigned int) GC_all_interior_pointers.40;
      D.5938 = lb - D.5937;
      lb = D.5938 + 8;
      goto <D.5567>;
      <D.5939>:
      <D.5567>:
      GC_all_interior_pointers.40 = GC_all_interior_pointers;
      D.5937 = (long unsigned int) GC_all_interior_pointers.40;
      D.5940 = 2048 - D.5937;
      if (D.5940 >= lb) goto <D.5941>; else goto <D.5942>;
      <D.5941>:
      D.5943 = GC_arrays._size_map[lb];
      lw = (word) D.5943;
      GC_arobjfreelist.41 = GC_arobjfreelist;
      D.5945 = lw * 8;
      opp = GC_arobjfreelist.41 + D.5945;
      D.5946 = GC_test_and_set (&GC_allocate_lock);
      if (D.5946 != 0) goto <D.5947>; else goto <D.5948>;
      <D.5947>:
      GC_lock ();
      <D.5948>:
      op = *opp;
      if (op == 0B) goto <D.5949>; else goto <D.5950>;
      <D.5949>:
      GC_clear (&GC_allocate_lock);
      GC_array_kind.42 = GC_array_kind;
      D.5952 = GC_generic_malloc (lb, GC_array_kind.42);
      op = GC_clear_stack (D.5952);
      if (op == 0B) goto <D.5953>; else goto <D.5954>;
      <D.5953>:
      D.5933 = 0B;
      return D.5933;
      <D.5954>:
      D.5943 = GC_arrays._size_map[lb];
      lw = (word) D.5943;
      goto <D.5955>;
      <D.5950>:
      D.5956 = MEM[(char * *)op];
      *opp = D.5956;
      MEM[(char * *)op] = 0B;
      D.5957 = GC_arrays._words_allocd;
      D.5958 = D.5957 + lw;
      GC_arrays._words_allocd = D.5958;
      GC_clear (&GC_allocate_lock);
      <D.5955>:
      goto <D.5959>;
      <D.5942>:
      GC_array_kind.42 = GC_array_kind;
      D.5960 = GC_generic_malloc (lb, GC_array_kind.42);
      op = GC_clear_stack (D.5960);
      if (op == 0B) goto <D.5961>; else goto <D.5962>;
      <D.5961>:
      D.5933 = 0B;
      return D.5933;
      <D.5962>:
      D.5963 = GC_size (op);
      lw = D.5963 >> 3;
      <D.5959>:
      if (descr_type == 1) goto <D.5964>; else goto <D.5965>;
      <D.5964>:
      {
        volatile struct LeafDescriptor * lp;

        D.5945 = lw * 8;
        D.5966 = D.5945 + 18446744073709551576;
        lp = op + D.5966;
        lp->ld_tag = 1;
        D.5967 = leaf.ld_size;
        lp->ld_size = D.5967;
        D.5968 = leaf.ld_nelements;
        lp->ld_nelements = D.5968;
        D.5969 = leaf.ld_descriptor;
        lp->ld_descriptor = D.5969;
        D.5945 = lw * 8;
        D.5970 = D.5945 + 18446744073709551608;
        D.5971 = op + D.5970;
        lp.43 = (long unsigned int) lp;
        *D.5971 = lp.43;
      }
      goto <D.5973>;
      <D.5965>:
      {
        extern unsigned int GC_finalization_failures;
        unsigned int ff;

        ff = GC_finalization_failures;
        D.5945 = lw * 8;
        D.5970 = D.5945 + 18446744073709551608;
        D.5974 = op + D.5970;
        complex_descr.44 = complex_descr;
        complex_descr.45 = (long unsigned int) complex_descr.44;
        *D.5974 = complex_descr.45;
        D.5945 = lw * 8;
        D.5970 = D.5945 + 18446744073709551608;
        D.5977 = op + D.5970;
        GC_general_register_disappearing_link (D.5977, op);
        GC_finalization_failures.46 = GC_finalization_failures;
        if (ff != GC_finalization_failures.46) goto <D.5979>; else goto <D.5980>;
        <D.5979>:
        D.5934 = n * lb;
        D.5933 = GC_malloc (D.5934);
        return D.5933;
        <D.5980>:
      }
      <D.5973>:
      D.5933 = op;
      return D.5933;
    }
  finally
    {
      simple_descr = {CLOBBER};
      complex_descr = {CLOBBER};
      leaf = {CLOBBER};
    }
}