GC_add_ext_descriptor (GC_word * bm, word nbits)
{
  long unsigned int D.5088;
  int D.5089;
  signed_word D.5097;
  long unsigned int D.5098;
  int D.5101;
  long unsigned int GC_ed_size.0;
  long unsigned int GC_avail_descr.1;
  long unsigned int D.5110;
  struct ext_descr * GC_ext_descriptors.2;
  long unsigned int GC_avail_descr.4;
  long unsigned int result.3;
  long unsigned int D.5114;
  long unsigned int D.5115;
  struct ext_descr * D.5116;
  long unsigned int D.5117;
  GC_word * D.5118;
  long unsigned int D.5119;
  long unsigned int D.5120;
  unsigned int D.5121;
  unsigned int D.5122;
  unsigned int D.5123;
  unsigned int D.5124;
  register size_t nwords;
  register signed_word result;
  register word i;
  register word last_part;
  register int extra_bits;

  D.5088 = nbits + 63;
  nwords = D.5088 >> 6;
  D.5089 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5089 != 0) goto <D.5090>; else goto <D.5091>;
  <D.5090>:
  GC_lock ();
  <D.5091>:
  goto <D.4909>;
  <D.4908>:
  {
    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.5092>; else goto <D.5093>;
    <D.5092>:
    new_size = 100;
    goto <D.5094>;
    <D.5093>:
    new_size = ed_size * 2;
    if (new_size > 72057594037927935) goto <D.5095>; else goto <D.5096>;
    <D.5095>:
    D.5097 = -1;
    return D.5097;
    <D.5096>:
    <D.5094>:
    D.5098 = new_size * 16;
    new = GC_malloc_atomic (D.5098);
    if (new == 0B) goto <D.5099>; else goto <D.5100>;
    <D.5099>:
    D.5097 = -1;
    return D.5097;
    <D.5100>:
    D.5101 = pthread_mutex_trylock (&GC_allocate_ml);
    if (D.5101 != 0) goto <D.5102>; else goto <D.5103>;
    <D.5102>:
    GC_lock ();
    <D.5103>:
    GC_ed_size.0 = GC_ed_size;
    if (ed_size == GC_ed_size.0) goto <D.5105>; else goto <D.5106>;
    <D.5105>:
    GC_avail_descr.1 = GC_avail_descr;
    if (GC_avail_descr.1 != 0) goto <D.5108>; else goto <D.5109>;
    <D.5108>:
    GC_avail_descr.1 = GC_avail_descr;
    D.5110 = GC_avail_descr.1 * 16;
    GC_ext_descriptors.2 = GC_ext_descriptors;
    memcpy (new, GC_ext_descriptors.2, D.5110);
    <D.5109>:
    GC_ed_size = new_size;
    GC_ext_descriptors = new;
    <D.5106>:
  }
  <D.4909>:
  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.4908>; else goto <D.4910>;
  <D.4910>:
  GC_avail_descr.1 = GC_avail_descr;
  result = (signed_word) GC_avail_descr.1;
  i = 0;
  goto <D.4912>;
  <D.4911>:
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.5114 = result.3 + i;
  D.5115 = D.5114 * 16;
  D.5116 = GC_ext_descriptors.2 + D.5115;
  D.5117 = i * 8;
  D.5118 = bm + D.5117;
  D.5119 = *D.5118;
  D.5116->ed_bitmap = D.5119;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.5114 = result.3 + i;
  D.5115 = D.5114 * 16;
  D.5116 = GC_ext_descriptors.2 + D.5115;
  D.5116->ed_continued = 1;
  i = i + 1;
  <D.4912>:
  D.5120 = nwords + 18446744073709551615;
  if (D.5120 > i) goto <D.4911>; else goto <D.4913>;
  <D.4913>:
  D.5117 = i * 8;
  D.5118 = bm + D.5117;
  last_part = *D.5118;
  D.5121 = (unsigned int) nwords;
  D.5122 = D.5121 * 64;
  D.5123 = (unsigned int) nbits;
  D.5124 = D.5122 - D.5123;
  extra_bits = (int) D.5124;
  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.5114 = result.3 + i;
  D.5115 = D.5114 * 16;
  D.5116 = GC_ext_descriptors.2 + D.5115;
  D.5116->ed_bitmap = last_part;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.5114 = result.3 + i;
  D.5115 = D.5114 * 16;
  D.5116 = GC_ext_descriptors.2 + D.5115;
  D.5116->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.5097 = result;
  return D.5097;
}


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

  D.5127 = __builtin_object_size (__dest, 0);
  D.5126 = __builtin___memcpy_chk (__dest, __src, __len, D.5127);
  return D.5126;
}


GC_double_descr (GC_descr descriptor, word nwords)
{
  long unsigned int D.5129;
  long unsigned int D.5132;
  long unsigned int D.5133;
  int D.5134;
  long unsigned int D.5135;
  GC_descr D.5136;

  D.5129 = descriptor & 3;
  if (D.5129 == 0) goto <D.5130>; else goto <D.5131>;
  <D.5130>:
  D.5132 = descriptor >> 3;
  descriptor = GC_bm_table[D.5132];
  <D.5131>:
  D.5133 = descriptor & 18446744073709551612;
  D.5134 = (int) nwords;
  D.5135 = D.5133 >> D.5134;
  descriptor = D.5135 | descriptor;
  D.5136 = descriptor;
  return D.5136;
}


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.5138;
  long unsigned int D.5143;
  int D.5144;
  long unsigned int D.5158;
  long unsigned int D.5161;
  long unsigned int D.5162;
  long unsigned int D.5163;
  long unsigned int D.5164;
  long unsigned int D.5165;
  _Bool D.5168;
  _Bool D.5169;
  _Bool D.5170;
  long unsigned int D.5175;
  union complex_descriptor * D.5176;
  long unsigned int D.5179;
  long unsigned int D.5180;
  long unsigned int D.5181;
  union complex_descriptor * D.5182;
  union complex_descriptor * D.5183;
  union complex_descriptor * D.5184;

  D.5138 = descriptor & 3;
  if (D.5138 == 0) goto <D.5139>; else goto <D.5140>;
  <D.5139>:
  if (descriptor == size) goto <D.5141>; else goto <D.5142>;
  <D.5141>:
  D.5143 = nelements * descriptor;
  *simple_d = D.5143;
  D.5144 = 0;
  return D.5144;
  <D.5142>:
  if (descriptor == 0) goto <D.5145>; else goto <D.5146>;
  <D.5145>:
  *simple_d = 0;
  D.5144 = 0;
  return D.5144;
  <D.5146>:
  <D.5140>:
  if (nelements <= 50) goto <D.5147>; else goto <D.5148>;
  <D.5147>:
  if (nelements <= 1) goto <D.5149>; else goto <D.5150>;
  <D.5149>:
  if (nelements == 1) goto <D.5151>; else goto <D.5152>;
  <D.5151>:
  *simple_d = descriptor;
  D.5144 = 0;
  return D.5144;
  <D.5152>:
  *simple_d = 0;
  D.5144 = 0;
  return D.5144;
  <D.5150>:
  goto <D.5153>;
  <D.5148>:
  if (size <= 31) goto <D.5154>; else goto <D.5155>;
  <D.5154>:
  D.5138 = descriptor & 3;
  if (D.5138 != 2) goto <D.5156>; else goto <D.5157>;
  <D.5156>:
  D.5158 = size & 7;
  if (D.5158 == 0) goto <D.5159>; else goto <D.5160>;
  <D.5159>:
  {
    int result;

    D.5161 = size >> 3;
    D.5162 = GC_double_descr (descriptor, D.5161);
    D.5163 = size * 2;
    D.5164 = nelements / 2;
    result = GC_make_array_descriptor (D.5164, D.5163, D.5162, simple_d, complex_d, leaf);
    D.5165 = nelements & 1;
    if (D.5165 == 0) goto <D.5166>; else goto <D.5167>;
    <D.5166>:
    D.5144 = result;
    return D.5144;
    <D.5167>:
    {
      struct LeafDescriptor * one_element;

      one_element = GC_malloc_atomic (32);
      D.5168 = result == -1;
      D.5169 = one_element == 0B;
      D.5170 = D.5168 | D.5169;
      if (D.5170 != 0) goto <D.5171>; else goto <D.5172>;
      <D.5171>:
      D.5144 = -1;
      return D.5144;
      <D.5172>:
      one_element->ld_tag = 1;
      one_element->ld_size = size;
      one_element->ld_nelements = 1;
      one_element->ld_descriptor = descriptor;
      switch (result) <default: <D.5185>, case 0: <D.4930>, case 1: <D.4933>, case 2: <D.4935>>
      <D.4930>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (32);
        if (beginning == 0B) goto <D.5173>; else goto <D.5174>;
        <D.5173>:
        D.5144 = -1;
        return D.5144;
        <D.5174>:
        beginning->ld_tag = 1;
        beginning->ld_size = size;
        beginning->ld_nelements = 1;
        D.5175 = *simple_d;
        beginning->ld_descriptor = D.5175;
        D.5176 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.5176;
        goto <D.4932>;
      }
      <D.4933>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (32);
        if (beginning == 0B) goto <D.5177>; else goto <D.5178>;
        <D.5177>:
        D.5144 = -1;
        return D.5144;
        <D.5178>:
        beginning->ld_tag = 1;
        D.5179 = leaf->ld_size;
        beginning->ld_size = D.5179;
        D.5180 = leaf->ld_nelements;
        beginning->ld_nelements = D.5180;
        D.5181 = leaf->ld_descriptor;
        beginning->ld_descriptor = D.5181;
        D.5182 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.5182;
        goto <D.4932>;
      }
      <D.4935>:
      D.5183 = *complex_d;
      D.5184 = GC_make_sequence_descriptor (D.5183, one_element);
      *complex_d = D.5184;
      goto <D.4932>;
      <D.5185>:
      <D.4932>:
      D.5144 = 2;
      return D.5144;
    }
  }
  <D.5160>:
  <D.5157>:
  <D.5155>:
  <D.5153>:
  leaf->ld_size = size;
  leaf->ld_nelements = nelements;
  leaf->ld_descriptor = descriptor;
  D.5144 = 1;
  return D.5144;
}


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

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


GC_init_explicit_typing ()
{
  int D.5191;
  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;
  int GC_array_mark_proc_index.12;
  int D.5204;
  int D.5205;
  long unsigned int D.5206;
  char * * GC_arobjfreelist.13;
  int GC_array_kind.14;
  unsigned int i.15;
  unsigned int D.5210;
  int D.5211;
  long unsigned int D.5212;
  unsigned int i.16;
  register int i;

  D.5191 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5191 != 0) goto <D.5192>; else goto <D.5193>;
  <D.5192>:
  GC_lock ();
  <D.5193>:
  GC_explicit_typing_initialized.5 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.5 != 0) goto <D.5195>; else goto <D.5196>;
  <D.5195>:
  pthread_mutex_unlock (&GC_allocate_ml);
  return;
  <D.5196>:
  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_array_mark_proc_index.12 = GC_array_mark_proc_index;
  D.5204 = GC_array_mark_proc_index.12 << 2;
  D.5205 = D.5204 | 2;
  D.5206 = (long unsigned int) D.5205;
  GC_arobjfreelist.13 = GC_arobjfreelist;
  GC_array_kind.14 = GC_new_kind_inner (GC_arobjfreelist.13, D.5206, 0, 1);
  GC_array_kind = GC_array_kind.14;
  i = 0;
  goto <D.4958>;
  <D.4957>:
  {
    GC_descr d;

    i.15 = (unsigned int) i;
    D.5210 = 64 - i.15;
    D.5211 = (int) D.5210;
    D.5212 = 18446744073709551615 >> D.5211;
    i.15 = (unsigned int) i;
    D.5210 = 64 - i.15;
    D.5211 = (int) D.5210;
    d = D.5212 << D.5211;
    d = d | 1;
    GC_bm_table[i] = d;
  }
  i = i + 1;
  <D.4958>:
  i.16 = (unsigned int) i;
  if (i.16 <= 31) goto <D.4957>; else goto <D.4959>;
  <D.4959>:
  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.5216;
  struct ext_descr * D.5217;
  long unsigned int D.5218;
  char * current.18;
  _Bool D.5222;
  _Bool D.5223;
  _Bool D.5224;
  long unsigned int my_current.19;
  long unsigned int D.5228;
  long unsigned int D.5229;
  struct bottom_index * D.5231;
  long unsigned int D.5232;
  long unsigned int D.5233;
  long unsigned int my_hhdr.20;
  struct hdr * GC_invalid_header.21;
  long int my_current.22;
  int D.5239;
  map_entry_type * D.5240;
  sizetype D.5241;
  map_entry_type * D.5242;
  unsigned char D.5243;
  long unsigned int D.5248;
  long unsigned int D.5249;
  long unsigned int D.5250;
  long unsigned int D.5251;
  int GC_all_interior_pointers.23;
  int D.5263;
  sizetype D.5264;
  int D.5265;
  long unsigned int D.5266;
  long unsigned int D.5268;
  int D.5269;
  long unsigned int D.5275;
  long unsigned int D.5276;
  sizetype my_current.24;
  sizetype D.5278;
  sizetype D.5279;
  GC_word * D.5280;
  int D.5281;
  GC_word * D.5286;
  long unsigned int D.5287;
  long unsigned int D.5288;
  int GC_typed_mark_proc_index.25;
  long unsigned int D.5290;
  long unsigned int D.5291;
  long unsigned int D.5292;
  long unsigned int D.5293;
  struct mse * D.5294;
  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.5216 = env * 16;
  D.5217 = GC_ext_descriptors.17 + D.5216;
  bm = D.5217->ed_bitmap;
  current_p = addr;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  goto <D.4991>;
  <D.4990>:
  D.5218 = bm & 1;
  if (D.5218 != 0) goto <D.5219>; else goto <D.5220>;
  <D.5219>:
  current = *current_p;
  current.18 = (char *) current;
  D.5222 = current.18 >= least_ha;
  current.18 = (char *) current;
  D.5223 = current.18 <= greatest_ha;
  D.5224 = D.5222 & D.5223;
  if (D.5224 != 0) goto <D.5225>; else goto <D.5226>;
  <D.5225>:
  {
    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.5228 = hi & 2047;
          _bi = GC_arrays._top_index[D.5228];
          goto <D.4978>;
          <D.4977>:
          _bi = _bi->hash_link;
          <D.4978>:
          D.5229 = _bi->key;
          if (D.5229 != hi) goto <D.5230>; else goto <D.4979>;
          <D.5230>:
          D.5231 = GC_arrays._all_nils;
          if (D.5231 != _bi) goto <D.4977>; else goto <D.4979>;
          <D.4979>:
          bi = _bi;
        }
        my_current.19 = (long unsigned int) my_current;
        D.5232 = my_current.19 >> 12;
        D.5233 = D.5232 & 1023;
        _ha = &bi->index[D.5233];
      }
      my_hhdr = *_ha;
    }
    my_hhdr.20 = (long unsigned int) my_hhdr;
    if (my_hhdr.20 <= 4095) goto <D.5235>; else goto <D.5236>;
    <D.5235>:
    {
      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.5236>:
    {
      int displ;
      int map_entry;

      my_current.22 = (long int) my_current;
      D.5239 = (int) my_current.22;
      displ = D.5239 & 4095;
      D.5240 = my_hhdr->hb_map;
      D.5241 = (sizetype) displ;
      D.5242 = D.5240 + D.5241;
      D.5243 = *D.5242;
      map_entry = (int) D.5243;
      displ = displ >> 3;
      if (map_entry > 253) goto <D.5244>; else goto <D.5245>;
      <D.5244>:
      if (map_entry == 254) goto <D.5246>; else goto <D.5247>;
      <D.5246>:
      D.5248 = (long unsigned int) displ;
      D.5249 = my_hhdr->hb_sz;
      D.5250 = D.5248 % D.5249;
      map_entry = (int) D.5250;
      displ = displ - map_entry;
      D.5248 = (long unsigned int) displ;
      D.5249 = my_hhdr->hb_sz;
      D.5251 = D.5248 + D.5249;
      if (D.5251 > 512) goto <D.5252>; else goto <D.5253>;
      <D.5252>:
      GC_all_interior_pointers.23 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.23 != 0) goto <D.5255>; else goto <D.5256>;
      <D.5255>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.19);
      goto <D.5257>;
      <D.5256>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.19);
      <D.5257>:
      goto exit1;
      <D.5253>:
      goto <D.5258>;
      <D.5247>:
      GC_all_interior_pointers.23 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.23 != 0) goto <D.5259>; else goto <D.5260>;
      <D.5259>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.19);
      goto <D.5261>;
      <D.5260>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.19);
      <D.5261>:
      goto exit1;
      <D.5258>:
      goto <D.5262>;
      <D.5245>:
      displ = displ - map_entry;
      <D.5262>:
      {
        register word * mark_word_addr;

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

          D.5265 = displ & 63;
          my_bits = 1 << D.5265;
          <D.4987>:
          old = MEM[(volatile word *)mark_word_addr];
          D.5266 = old & my_bits;
          if (D.5266 != 0) goto exit1; else goto <D.5267>;
          <D.5267>:
          D.5268 = old | my_bits;
          D.5269 = GC_compare_and_exchange (mark_word_addr, old, D.5268);
          if (D.5269 == 0) goto <D.4987>; else goto <D.4988>;
          <D.4988>:
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.5270>; else goto <D.5271>;
        <D.5270>:
        goto <D.5272>;
        <D.5271>:
        mark_stack_ptr = mark_stack_ptr + 16;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.5273>; else goto <D.5274>;
        <D.5273>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.5274>:
        D.5275 = (long unsigned int) displ;
        D.5276 = D.5275 * 8;
        my_current.24 = (sizetype) my_current;
        D.5278 = my_current.24 & 18446744073709547520;
        D.5279 = D.5276 + D.5278;
        D.5280 = (GC_word *) D.5279;
        mark_stack_ptr->mse_start = D.5280;
        mark_stack_ptr->mse_descr = _descr;
        <D.5272>:
      }
    }
    exit1:
  }
  <D.5226>:
  <D.5220>:
  bm = bm >> 1;
  current_p = current_p + 8;
  <D.4991>:
  if (bm != 0) goto <D.4990>; else goto <D.4992>;
  <D.4992>:
  GC_ext_descriptors.17 = GC_ext_descriptors;
  D.5216 = env * 16;
  D.5217 = GC_ext_descriptors.17 + D.5216;
  D.5281 = D.5217->ed_continued;
  if (D.5281 != 0) goto <D.5282>; else goto <D.5283>;
  <D.5282>:
  mark_stack_ptr = mark_stack_ptr + 16;
  if (mark_stack_ptr >= mark_stack_limit) goto <D.5284>; else goto <D.5285>;
  <D.5284>:
  mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
  <D.5285>:
  D.5286 = addr + 512;
  mark_stack_ptr->mse_start = D.5286;
  D.5287 = env + 1;
  D.5288 = D.5287 << 6;
  GC_typed_mark_proc_index.25 = GC_typed_mark_proc_index;
  D.5290 = (long unsigned int) GC_typed_mark_proc_index.25;
  D.5291 = D.5288 | D.5290;
  D.5292 = D.5291 << 2;
  D.5293 = D.5292 | 2;
  mark_stack_ptr->mse_descr = D.5293;
  <D.5283>:
  D.5294 = mark_stack_ptr;
  return D.5294;
}


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

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


GC_descr_obj_size (union complex_descriptor * d)
{
  long unsigned int D.5298;
  word D.5299;
  long unsigned int D.5300;
  long unsigned int D.5301;
  long unsigned int D.5302;
  union ComplexDescriptor * D.5303;
  long unsigned int D.5304;
  union ComplexDescriptor * D.5305;
  long unsigned int D.5306;
  union ComplexDescriptor * D.5307;
  long unsigned int D.5308;

  D.5298 = d->ld.ld_tag;
  switch (D.5298) <default: <D.4999>, case 1: <D.4996>, case 2: <D.4997>, case 3: <D.4998>>
  <D.4996>:
  D.5300 = d->ld.ld_nelements;
  D.5301 = d->ld.ld_size;
  D.5299 = D.5300 * D.5301;
  return D.5299;
  <D.4997>:
  D.5302 = d->ad.ad_nelements;
  D.5303 = d->ad.ad_element_descr;
  D.5304 = GC_descr_obj_size (D.5303);
  D.5299 = D.5302 * D.5304;
  return D.5299;
  <D.4998>:
  D.5305 = d->sd.sd_first;
  D.5306 = GC_descr_obj_size (D.5305);
  D.5307 = d->sd.sd_second;
  D.5308 = GC_descr_obj_size (D.5307);
  D.5299 = D.5306 + D.5308;
  return D.5299;
  <D.4999>:
  GC_abort ("Bad complex descriptor");
  D.5299 = 0;
  return D.5299;
}


GC_push_complex_descriptor (word * addr, union complex_descriptor * d, struct mse * msp, struct mse * msl)
{
  long unsigned int D.5310;
  long int msl.26;
  long int msp.27;
  long int D.5313;
  long int D.5314;
  long int nelements.28;
  struct mse * D.5318;
  union ComplexDescriptor * D.5321;
  union ComplexDescriptor * D.5324;
  register char * current;
  register word nelements;
  register word sz;
  register word i;

  current = addr;
  D.5310 = d->ld.ld_tag;
  switch (D.5310) <default: <D.5021>, case 1: <D.5010>, case 2: <D.5015>, case 3: <D.5020>>
  <D.5010>:
  {
    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.5313 = msl.26 - msp.27;
    D.5314 = D.5313 /[ex] 16;
    nelements.28 = (long int) nelements;
    if (D.5314 <= nelements.28) goto <D.5316>; else goto <D.5317>;
    <D.5316>:
    D.5318 = 0B;
    return D.5318;
    <D.5317>:
    sz = d->ld.ld_size;
    i = 0;
    goto <D.5013>;
    <D.5012>:
    msp = msp + 16;
    msp->mse_start = current;
    msp->mse_descr = descr;
    current = current + sz;
    i = i + 1;
    <D.5013>:
    if (i < nelements) goto <D.5012>; else goto <D.5014>;
    <D.5014>:
    D.5318 = msp;
    return D.5318;
  }
  <D.5015>:
  {
    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.5018>;
    <D.5017>:
    msp = GC_push_complex_descriptor (current, descr, msp, msl);
    if (msp == 0B) goto <D.5319>; else goto <D.5320>;
    <D.5319>:
    D.5318 = 0B;
    return D.5318;
    <D.5320>:
    current = current + sz;
    i = i + 1;
    <D.5018>:
    if (i < nelements) goto <D.5017>; else goto <D.5019>;
    <D.5019>:
    D.5318 = msp;
    return D.5318;
  }
  <D.5020>:
  D.5321 = d->sd.sd_first;
  sz = GC_descr_obj_size (D.5321);
  D.5321 = d->sd.sd_first;
  msp = GC_push_complex_descriptor (current, D.5321, msp, msl);
  if (msp == 0B) goto <D.5322>; else goto <D.5323>;
  <D.5322>:
  D.5318 = 0B;
  return D.5318;
  <D.5323>:
  current = current + sz;
  D.5324 = d->sd.sd_second;
  msp = GC_push_complex_descriptor (current, D.5324, msp, msl);
  D.5318 = msp;
  return D.5318;
  <D.5021>:
  GC_abort ("Bad complex descriptor");
  D.5318 = 0B;
  return D.5318;
}


GC_array_mark_proc (word * addr, struct mse * mark_stack_ptr, struct mse * mark_stack_limit, word env)
{
  long unsigned int D.5326;
  sizetype D.5327;
  word * D.5328;
  long unsigned int D.5329;
  struct mse * D.5332;
  struct mse * D.5333;
  long unsigned int D.5336;
  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.5326 = sz * 8;
  D.5327 = D.5326 + 18446744073709551608;
  D.5328 = addr + D.5327;
  D.5329 = *D.5328;
  descr = (union complex_descriptor *) D.5329;
  orig_mark_stack_ptr = mark_stack_ptr;
  if (descr == 0B) goto <D.5330>; else goto <D.5331>;
  <D.5330>:
  D.5332 = orig_mark_stack_ptr;
  return D.5332;
  <D.5331>:
  D.5333 = mark_stack_limit + 18446744073709551600;
  new_mark_stack_ptr = GC_push_complex_descriptor (addr, descr, mark_stack_ptr, D.5333);
  if (new_mark_stack_ptr == 0B) goto <D.5334>; else goto <D.5335>;
  <D.5334>:
  GC_mark_stack_too_small = 1;
  new_mark_stack_ptr = orig_mark_stack_ptr + 16;
  new_mark_stack_ptr->mse_start = addr;
  D.5336 = sz << 3;
  new_mark_stack_ptr->mse_descr = D.5336;
  goto <D.5337>;
  <D.5335>:
  new_mark_stack_ptr = new_mark_stack_ptr + 16;
  D.5326 = sz * 8;
  D.5327 = D.5326 + 18446744073709551608;
  D.5328 = addr + D.5327;
  new_mark_stack_ptr->mse_start = D.5328;
  new_mark_stack_ptr->mse_descr = 8;
  <D.5337>:
  D.5332 = new_mark_stack_ptr;
  return D.5332;
}


GC_make_descriptor (GC_word * bm, size_t len)
{
  long unsigned int D.5339;
  int GC_explicit_typing_initialized.29;
  long unsigned int last_set_bit.30;
  long unsigned int D.5345;
  long unsigned int D.5346;
  GC_word * D.5347;
  long unsigned int D.5348;
  int D.5349;
  int D.5350;
  long unsigned int D.5351;
  long unsigned int D.5352;
  GC_descr D.5355;
  long unsigned int D.5356;
  long unsigned int D.5357;
  long unsigned int D.5358;
  GC_word * D.5359;
  long unsigned int D.5360;
  int D.5361;
  long unsigned int D.5362;
  long unsigned int D.5363;
  long int D.5366;
  long int D.5369;
  long int D.5370;
  unsigned int D.5373;
  unsigned int D.5374;
  long unsigned int D.5377;
  long unsigned int index.31;
  long unsigned int D.5381;
  int GC_typed_mark_proc_index.32;
  long unsigned int D.5383;
  long unsigned int D.5384;
  long unsigned int D.5385;
  register signed_word last_set_bit;
  register word result;
  register int i;

  D.5339 = len + 18446744073709551615;
  last_set_bit = (signed_word) D.5339;
  GC_explicit_typing_initialized.29 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.29 == 0) goto <D.5341>; else goto <D.5342>;
  <D.5341>:
  GC_init_explicit_typing ();
  <D.5342>:
  goto <D.5041>;
  <D.5040>:
  last_set_bit = last_set_bit + -1;
  <D.5041>:
  if (last_set_bit >= 0) goto <D.5343>; else goto <D.5042>;
  <D.5343>:
  last_set_bit.30 = (long unsigned int) last_set_bit;
  D.5345 = last_set_bit.30 / 64;
  D.5346 = D.5345 * 8;
  D.5347 = bm + D.5346;
  D.5348 = *D.5347;
  D.5349 = (int) last_set_bit;
  D.5350 = D.5349 & 63;
  D.5351 = D.5348 >> D.5350;
  D.5352 = D.5351 & 1;
  if (D.5352 == 0) goto <D.5040>; else goto <D.5042>;
  <D.5042>:
  if (last_set_bit < 0) goto <D.5353>; else goto <D.5354>;
  <D.5353>:
  D.5355 = 0;
  return D.5355;
  <D.5354>:
  {
    register GC_bool all_bits_set;

    all_bits_set = 1;
    i = 0;
    goto <D.5046>;
    <D.5045>:
    D.5356 = (long unsigned int) i;
    D.5357 = D.5356 / 64;
    D.5358 = D.5357 * 8;
    D.5359 = bm + D.5358;
    D.5360 = *D.5359;
    D.5361 = i & 63;
    D.5362 = D.5360 >> D.5361;
    D.5363 = D.5362 & 1;
    if (D.5363 == 0) goto <D.5364>; else goto <D.5365>;
    <D.5364>:
    all_bits_set = 0;
    goto <D.5044>;
    <D.5365>:
    i = i + 1;
    <D.5046>:
    D.5366 = (long int) i;
    if (D.5366 < last_set_bit) goto <D.5045>; else goto <D.5044>;
    <D.5044>:
    if (all_bits_set != 0) goto <D.5367>; else goto <D.5368>;
    <D.5367>:
    D.5369 = last_set_bit + 1;
    D.5370 = D.5369 << 3;
    D.5355 = (GC_descr) D.5370;
    return D.5355;
    <D.5368>:
  }
  last_set_bit.30 = (long unsigned int) last_set_bit;
  if (last_set_bit.30 <= 61) goto <D.5371>; else goto <D.5372>;
  <D.5371>:
  result = 9223372036854775808;
  D.5373 = (unsigned int) last_set_bit;
  D.5374 = D.5373 + 4294967295;
  i = (int) D.5374;
  goto <D.5048>;
  <D.5047>:
  result = result >> 1;
  D.5356 = (long unsigned int) i;
  D.5357 = D.5356 / 64;
  D.5358 = D.5357 * 8;
  D.5359 = bm + D.5358;
  D.5360 = *D.5359;
  D.5361 = i & 63;
  D.5362 = D.5360 >> D.5361;
  D.5363 = D.5362 & 1;
  if (D.5363 != 0) goto <D.5375>; else goto <D.5376>;
  <D.5375>:
  result = result | 9223372036854775808;
  <D.5376>:
  i = i + -1;
  <D.5048>:
  if (i >= 0) goto <D.5047>; else goto <D.5049>;
  <D.5049>:
  result = result | 1;
  D.5355 = result;
  return D.5355;
  <D.5372>:
  {
    signed_word index;

    last_set_bit.30 = (long unsigned int) last_set_bit;
    D.5377 = last_set_bit.30 + 1;
    index = GC_add_ext_descriptor (bm, D.5377);
    if (index == -1) goto <D.5378>; else goto <D.5379>;
    <D.5378>:
    D.5369 = last_set_bit + 1;
    D.5370 = D.5369 << 3;
    D.5355 = (GC_descr) D.5370;
    return D.5355;
    <D.5379>:
    index.31 = (long unsigned int) index;
    D.5381 = index.31 << 6;
    GC_typed_mark_proc_index.32 = GC_typed_mark_proc_index;
    D.5383 = (long unsigned int) GC_typed_mark_proc_index.32;
    D.5384 = D.5381 | D.5383;
    D.5385 = D.5384 << 2;
    result = D.5385 | 2;
    D.5355 = result;
    return D.5355;
  }
}


GC_malloc_explicitly_typed (size_t lb, GC_descr d)
{
  int GC_all_interior_pointers.33;
  long unsigned int D.5388;
  long unsigned int D.5389;
  long unsigned int D.5390;
  unsigned int D.5393;
  char * * GC_eobjfreelist.34;
  long unsigned int D.5395;
  int D.5396;
  int GC_explicit_kind.35;
  char * D.5402;
  void * D.5405;
  char * D.5407;
  long unsigned int D.5408;
  long unsigned int D.5409;
  char * D.5411;
  long unsigned int D.5414;
  sizetype D.5417;
  word * D.5418;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.33 = GC_all_interior_pointers;
  D.5388 = (long unsigned int) GC_all_interior_pointers.33;
  D.5389 = lb - D.5388;
  lb = D.5389 + 8;
  GC_all_interior_pointers.33 = GC_all_interior_pointers;
  D.5388 = (long unsigned int) GC_all_interior_pointers.33;
  D.5390 = 2048 - D.5388;
  if (D.5390 >= lb) goto <D.5391>; else goto <D.5392>;
  <D.5391>:
  D.5393 = GC_arrays._size_map[lb];
  lw = (word) D.5393;
  GC_eobjfreelist.34 = GC_eobjfreelist;
  D.5395 = lw * 8;
  opp = GC_eobjfreelist.34 + D.5395;
  D.5396 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5396 != 0) goto <D.5397>; else goto <D.5398>;
  <D.5397>:
  GC_lock ();
  <D.5398>:
  op = *opp;
  if (op == 0B) goto <D.5399>; else goto <D.5400>;
  <D.5399>:
  pthread_mutex_unlock (&GC_allocate_ml);
  GC_explicit_kind.35 = GC_explicit_kind;
  D.5402 = GC_generic_malloc (lb, GC_explicit_kind.35);
  op = GC_clear_stack (D.5402);
  if (op == 0B) goto <D.5403>; else goto <D.5404>;
  <D.5403>:
  D.5405 = 0B;
  return D.5405;
  <D.5404>:
  D.5393 = GC_arrays._size_map[lb];
  lw = (word) D.5393;
  goto <D.5406>;
  <D.5400>:
  D.5407 = MEM[(char * *)op];
  *opp = D.5407;
  MEM[(char * *)op] = 0B;
  D.5408 = GC_arrays._words_allocd;
  D.5409 = D.5408 + lw;
  GC_arrays._words_allocd = D.5409;
  pthread_mutex_unlock (&GC_allocate_ml);
  <D.5406>:
  goto <D.5410>;
  <D.5392>:
  GC_explicit_kind.35 = GC_explicit_kind;
  D.5411 = GC_generic_malloc (lb, GC_explicit_kind.35);
  op = GC_clear_stack (D.5411);
  if (op != 0B) goto <D.5412>; else goto <D.5413>;
  <D.5412>:
  D.5414 = GC_size (op);
  lw = D.5414 >> 3;
  <D.5413>:
  <D.5410>:
  if (op != 0B) goto <D.5415>; else goto <D.5416>;
  <D.5415>:
  D.5395 = lw * 8;
  D.5417 = D.5395 + 18446744073709551608;
  D.5418 = op + D.5417;
  *D.5418 = d;
  <D.5416>:
  D.5405 = op;
  return D.5405;
}


GC_malloc_explicitly_typed_ignore_off_page (size_t lb, GC_descr d)
{
  int GC_all_interior_pointers.36;
  long unsigned int D.5421;
  long unsigned int D.5422;
  long unsigned int D.5423;
  unsigned int D.5426;
  char * * GC_eobjfreelist.37;
  long unsigned int D.5428;
  int D.5429;
  int GC_explicit_kind.38;
  char * D.5435;
  char * D.5437;
  long unsigned int D.5438;
  long unsigned int D.5439;
  char * D.5441;
  long unsigned int D.5444;
  sizetype D.5447;
  word * D.5448;
  void * D.5449;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.36 = GC_all_interior_pointers;
  D.5421 = (long unsigned int) GC_all_interior_pointers.36;
  D.5422 = lb - D.5421;
  lb = D.5422 + 8;
  GC_all_interior_pointers.36 = GC_all_interior_pointers;
  D.5421 = (long unsigned int) GC_all_interior_pointers.36;
  D.5423 = 2048 - D.5421;
  if (D.5423 >= lb) goto <D.5424>; else goto <D.5425>;
  <D.5424>:
  D.5426 = GC_arrays._size_map[lb];
  lw = (word) D.5426;
  GC_eobjfreelist.37 = GC_eobjfreelist;
  D.5428 = lw * 8;
  opp = GC_eobjfreelist.37 + D.5428;
  D.5429 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5429 != 0) goto <D.5430>; else goto <D.5431>;
  <D.5430>:
  GC_lock ();
  <D.5431>:
  op = *opp;
  if (op == 0B) goto <D.5432>; else goto <D.5433>;
  <D.5432>:
  pthread_mutex_unlock (&GC_allocate_ml);
  GC_explicit_kind.38 = GC_explicit_kind;
  D.5435 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.38);
  op = GC_clear_stack (D.5435);
  D.5426 = GC_arrays._size_map[lb];
  lw = (word) D.5426;
  goto <D.5436>;
  <D.5433>:
  D.5437 = MEM[(char * *)op];
  *opp = D.5437;
  MEM[(char * *)op] = 0B;
  D.5438 = GC_arrays._words_allocd;
  D.5439 = D.5438 + lw;
  GC_arrays._words_allocd = D.5439;
  pthread_mutex_unlock (&GC_allocate_ml);
  <D.5436>:
  goto <D.5440>;
  <D.5425>:
  GC_explicit_kind.38 = GC_explicit_kind;
  D.5441 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.38);
  op = GC_clear_stack (D.5441);
  if (op != 0B) goto <D.5442>; else goto <D.5443>;
  <D.5442>:
  D.5444 = GC_size (op);
  lw = D.5444 >> 3;
  <D.5443>:
  <D.5440>:
  if (op != 0B) goto <D.5445>; else goto <D.5446>;
  <D.5445>:
  D.5428 = lw * 8;
  D.5447 = D.5428 + 18446744073709551608;
  D.5448 = op + D.5447;
  *D.5448 = d;
  <D.5446>:
  D.5449 = op;
  return D.5449;
}


GC_calloc_explicitly_typed (size_t n, size_t lb, GC_descr d)
{
  void * D.5451;
  long unsigned int simple_descr.39;
  long unsigned int D.5453;
  int GC_all_interior_pointers.40;
  long unsigned int D.5455;
  long unsigned int D.5456;
  long unsigned int D.5458;
  unsigned int D.5461;
  char * * GC_arobjfreelist.41;
  long unsigned int D.5463;
  int D.5464;
  int GC_array_kind.42;
  char * D.5470;
  char * D.5474;
  long unsigned int D.5475;
  long unsigned int D.5476;
  char * D.5478;
  long unsigned int D.5481;
  sizetype D.5484;
  long unsigned int D.5485;
  long unsigned int D.5486;
  long unsigned int D.5487;
  sizetype D.5488;
  volatile word * D.5489;
  long unsigned int lp.43;
  word * D.5492;
  union complex_descriptor * complex_descr.44;
  long unsigned int complex_descr.45;
  void * * D.5495;
  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.5457>, case -1: <D.5078>, case 0: <D.5079>, case 1: <D.5080>, case 2: <D.5082>>
      <D.5078>:
      D.5451 = 0B;
      return D.5451;
      <D.5079>:
      simple_descr.39 = simple_descr;
      D.5453 = n * lb;
      D.5451 = GC_malloc_explicitly_typed (D.5453, simple_descr.39);
      return D.5451;
      <D.5080>:
      lb = lb * n;
      GC_all_interior_pointers.40 = GC_all_interior_pointers;
      D.5455 = (long unsigned int) GC_all_interior_pointers.40;
      D.5456 = lb - D.5455;
      lb = D.5456 + 40;
      goto <D.5081>;
      <D.5082>:
      lb = lb * n;
      GC_all_interior_pointers.40 = GC_all_interior_pointers;
      D.5455 = (long unsigned int) GC_all_interior_pointers.40;
      D.5456 = lb - D.5455;
      lb = D.5456 + 8;
      goto <D.5081>;
      <D.5457>:
      <D.5081>:
      GC_all_interior_pointers.40 = GC_all_interior_pointers;
      D.5455 = (long unsigned int) GC_all_interior_pointers.40;
      D.5458 = 2048 - D.5455;
      if (D.5458 >= lb) goto <D.5459>; else goto <D.5460>;
      <D.5459>:
      D.5461 = GC_arrays._size_map[lb];
      lw = (word) D.5461;
      GC_arobjfreelist.41 = GC_arobjfreelist;
      D.5463 = lw * 8;
      opp = GC_arobjfreelist.41 + D.5463;
      D.5464 = pthread_mutex_trylock (&GC_allocate_ml);
      if (D.5464 != 0) goto <D.5465>; else goto <D.5466>;
      <D.5465>:
      GC_lock ();
      <D.5466>:
      op = *opp;
      if (op == 0B) goto <D.5467>; else goto <D.5468>;
      <D.5467>:
      pthread_mutex_unlock (&GC_allocate_ml);
      GC_array_kind.42 = GC_array_kind;
      D.5470 = GC_generic_malloc (lb, GC_array_kind.42);
      op = GC_clear_stack (D.5470);
      if (op == 0B) goto <D.5471>; else goto <D.5472>;
      <D.5471>:
      D.5451 = 0B;
      return D.5451;
      <D.5472>:
      D.5461 = GC_arrays._size_map[lb];
      lw = (word) D.5461;
      goto <D.5473>;
      <D.5468>:
      D.5474 = MEM[(char * *)op];
      *opp = D.5474;
      MEM[(char * *)op] = 0B;
      D.5475 = GC_arrays._words_allocd;
      D.5476 = D.5475 + lw;
      GC_arrays._words_allocd = D.5476;
      pthread_mutex_unlock (&GC_allocate_ml);
      <D.5473>:
      goto <D.5477>;
      <D.5460>:
      GC_array_kind.42 = GC_array_kind;
      D.5478 = GC_generic_malloc (lb, GC_array_kind.42);
      op = GC_clear_stack (D.5478);
      if (op == 0B) goto <D.5479>; else goto <D.5480>;
      <D.5479>:
      D.5451 = 0B;
      return D.5451;
      <D.5480>:
      D.5481 = GC_size (op);
      lw = D.5481 >> 3;
      <D.5477>:
      if (descr_type == 1) goto <D.5482>; else goto <D.5483>;
      <D.5482>:
      {
        volatile struct LeafDescriptor * lp;

        D.5463 = lw * 8;
        D.5484 = D.5463 + 18446744073709551576;
        lp = op + D.5484;
        lp->ld_tag = 1;
        D.5485 = leaf.ld_size;
        lp->ld_size = D.5485;
        D.5486 = leaf.ld_nelements;
        lp->ld_nelements = D.5486;
        D.5487 = leaf.ld_descriptor;
        lp->ld_descriptor = D.5487;
        D.5463 = lw * 8;
        D.5488 = D.5463 + 18446744073709551608;
        D.5489 = op + D.5488;
        lp.43 = (long unsigned int) lp;
        *D.5489 = lp.43;
      }
      goto <D.5491>;
      <D.5483>:
      {
        extern unsigned int GC_finalization_failures;
        unsigned int ff;

        ff = GC_finalization_failures;
        D.5463 = lw * 8;
        D.5488 = D.5463 + 18446744073709551608;
        D.5492 = op + D.5488;
        complex_descr.44 = complex_descr;
        complex_descr.45 = (long unsigned int) complex_descr.44;
        *D.5492 = complex_descr.45;
        D.5463 = lw * 8;
        D.5488 = D.5463 + 18446744073709551608;
        D.5495 = op + D.5488;
        GC_general_register_disappearing_link (D.5495, op);
        GC_finalization_failures.46 = GC_finalization_failures;
        if (ff != GC_finalization_failures.46) goto <D.5497>; else goto <D.5498>;
        <D.5497>:
        D.5453 = n * lb;
        D.5451 = GC_malloc (D.5453);
        return D.5451;
        <D.5498>:
      }
      <D.5491>:
      D.5451 = op;
      return D.5451;
    }
  finally
    {
      simple_descr = {CLOBBER};
      complex_descr = {CLOBBER};
      leaf = {CLOBBER};
    }
}