GC_add_ext_descriptor (GC_word * bm, word nbits)
{
  long unsigned int D.5170;
  int D.5171;
  signed_word D.5179;
  long unsigned int D.5180;
  int D.5183;
  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.5193;
  long unsigned int D.5194;
  long unsigned int result.3;
  long unsigned int D.5196;
  long unsigned int D.5197;
  struct ext_descr * D.5198;
  long unsigned int D.5199;
  GC_word * D.5200;
  long unsigned int D.5201;
  long unsigned int D.5202;
  unsigned int D.5203;
  unsigned int D.5204;
  unsigned int D.5205;
  unsigned int D.5206;
  register size_t nwords;
  register signed_word result;
  register word i;
  register word last_part;
  register int extra_bits;

  D.5170 = nbits + 63;
  nwords = D.5170 >> 6;
  D.5171 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5171 != 0) goto <D.5172>; else goto <D.5173>;
  <D.5172>:
  GC_lock ();
  <D.5173>:
  goto <D.4991>;
  <D.4990>:
  {
    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.5174>; else goto <D.5175>;
    <D.5174>:
    new_size = 100;
    goto <D.5176>;
    <D.5175>:
    new_size = ed_size * 2;
    if (new_size > 72057594037927935) goto <D.5177>; else goto <D.5178>;
    <D.5177>:
    D.5179 = -1;
    return D.5179;
    <D.5178>:
    <D.5176>:
    D.5180 = new_size * 16;
    new = GC_malloc_atomic (D.5180);
    if (new == 0B) goto <D.5181>; else goto <D.5182>;
    <D.5181>:
    D.5179 = -1;
    return D.5179;
    <D.5182>:
    D.5183 = pthread_mutex_trylock (&GC_allocate_ml);
    if (D.5183 != 0) goto <D.5184>; else goto <D.5185>;
    <D.5184>:
    GC_lock ();
    <D.5185>:
    GC_ed_size.0 = GC_ed_size;
    if (ed_size == GC_ed_size.0) goto <D.5187>; else goto <D.5188>;
    <D.5187>:
    GC_avail_descr.1 = GC_avail_descr;
    if (GC_avail_descr.1 != 0) goto <D.5190>; else goto <D.5191>;
    <D.5190>:
    GC_ext_descriptors.2 = GC_ext_descriptors;
    GC_avail_descr.1 = GC_avail_descr;
    D.5193 = GC_avail_descr.1 * 16;
    memcpy (new, GC_ext_descriptors.2, D.5193);
    <D.5191>:
    GC_ed_size = new_size;
    GC_ext_descriptors = new;
    <D.5188>:
  }
  <D.4991>:
  GC_avail_descr.1 = GC_avail_descr;
  D.5194 = GC_avail_descr.1 + nwords;
  GC_ed_size.0 = GC_ed_size;
  if (D.5194 >= GC_ed_size.0) goto <D.4990>; else goto <D.4992>;
  <D.4992>:
  GC_avail_descr.1 = GC_avail_descr;
  result = (signed_word) GC_avail_descr.1;
  i = 0;
  goto <D.4994>;
  <D.4993>:
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.5196 = result.3 + i;
  D.5197 = D.5196 * 16;
  D.5198 = GC_ext_descriptors.2 + D.5197;
  D.5199 = i * 8;
  D.5200 = bm + D.5199;
  D.5201 = *D.5200;
  D.5198->ed_bitmap = D.5201;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.5196 = result.3 + i;
  D.5197 = D.5196 * 16;
  D.5198 = GC_ext_descriptors.2 + D.5197;
  D.5198->ed_continued = 1;
  i = i + 1;
  <D.4994>:
  D.5202 = nwords + 18446744073709551615;
  if (D.5202 > i) goto <D.4993>; else goto <D.4995>;
  <D.4995>:
  D.5199 = i * 8;
  D.5200 = bm + D.5199;
  last_part = *D.5200;
  D.5203 = (unsigned int) nwords;
  D.5204 = D.5203 * 64;
  D.5205 = (unsigned int) nbits;
  D.5206 = D.5204 - D.5205;
  extra_bits = (int) D.5206;
  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.5196 = result.3 + i;
  D.5197 = D.5196 * 16;
  D.5198 = GC_ext_descriptors.2 + D.5197;
  D.5198->ed_bitmap = last_part;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.5196 = result.3 + i;
  D.5197 = D.5196 * 16;
  D.5198 = GC_ext_descriptors.2 + D.5197;
  D.5198->ed_continued = 0;
  GC_avail_descr.1 = GC_avail_descr;
  D.5194 = GC_avail_descr.1 + nwords;
  GC_avail_descr = D.5194;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5179 = result;
  return D.5179;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.5208;
  long unsigned int D.5209;

  D.5209 = __builtin_object_size (__dest, 0);
  D.5208 = __builtin___memcpy_chk (__dest, __src, __len, D.5209);
  return D.5208;
}


GC_double_descr (GC_descr descriptor, word nwords)
{
  long unsigned int D.5211;
  long unsigned int D.5214;
  long unsigned int D.5215;
  unsigned int D.5216;
  long unsigned int D.5217;
  GC_descr D.5218;

  D.5211 = descriptor & 3;
  if (D.5211 == 0) goto <D.5212>; else goto <D.5213>;
  <D.5212>:
  D.5214 = descriptor >> 3;
  descriptor = GC_bm_table[D.5214];
  <D.5213>:
  D.5215 = descriptor & 18446744073709551612;
  D.5216 = (unsigned int) nwords;
  D.5217 = D.5215 >> D.5216;
  descriptor = D.5217 | descriptor;
  D.5218 = descriptor;
  return D.5218;
}


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.5220;
  long unsigned int D.5225;
  int D.5226;
  long unsigned int D.5240;
  long unsigned int D.5243;
  long unsigned int D.5244;
  long unsigned int D.5245;
  long unsigned int D.5246;
  long unsigned int D.5247;
  long unsigned int D.5255;
  union complex_descriptor * D.5256;
  long unsigned int D.5259;
  long unsigned int D.5260;
  long unsigned int D.5261;
  union complex_descriptor * D.5262;
  union complex_descriptor * D.5263;
  union complex_descriptor * D.5264;

  D.5220 = descriptor & 3;
  if (D.5220 == 0) goto <D.5221>; else goto <D.5222>;
  <D.5221>:
  if (descriptor == size) goto <D.5223>; else goto <D.5224>;
  <D.5223>:
  D.5225 = nelements * descriptor;
  *simple_d = D.5225;
  D.5226 = 0;
  return D.5226;
  <D.5224>:
  if (descriptor == 0) goto <D.5227>; else goto <D.5228>;
  <D.5227>:
  *simple_d = 0;
  D.5226 = 0;
  return D.5226;
  <D.5228>:
  <D.5222>:
  if (nelements <= 50) goto <D.5229>; else goto <D.5230>;
  <D.5229>:
  if (nelements <= 1) goto <D.5231>; else goto <D.5232>;
  <D.5231>:
  if (nelements == 1) goto <D.5233>; else goto <D.5234>;
  <D.5233>:
  *simple_d = descriptor;
  D.5226 = 0;
  return D.5226;
  <D.5234>:
  *simple_d = 0;
  D.5226 = 0;
  return D.5226;
  <D.5232>:
  goto <D.5235>;
  <D.5230>:
  if (size <= 31) goto <D.5236>; else goto <D.5237>;
  <D.5236>:
  D.5220 = descriptor & 3;
  if (D.5220 != 2) goto <D.5238>; else goto <D.5239>;
  <D.5238>:
  D.5240 = size & 7;
  if (D.5240 == 0) goto <D.5241>; else goto <D.5242>;
  <D.5241>:
  {
    int result;

    D.5243 = nelements / 2;
    D.5244 = size * 2;
    D.5245 = size >> 3;
    D.5246 = GC_double_descr (descriptor, D.5245);
    result = GC_make_array_descriptor (D.5243, D.5244, D.5246, simple_d, complex_d, leaf);
    D.5247 = nelements & 1;
    if (D.5247 == 0) goto <D.5248>; else goto <D.5249>;
    <D.5248>:
    D.5226 = result;
    return D.5226;
    <D.5249>:
    {
      struct LeafDescriptor * one_element;

      one_element = GC_malloc_atomic (32);
      if (result == -1) goto <D.5250>; else goto <D.5252>;
      <D.5252>:
      if (one_element == 0B) goto <D.5250>; else goto <D.5251>;
      <D.5250>:
      D.5226 = -1;
      return D.5226;
      <D.5251>:
      one_element->ld_tag = 1;
      one_element->ld_size = size;
      one_element->ld_nelements = 1;
      one_element->ld_descriptor = descriptor;
      switch (result) <default: <D.5265>, case 0: <D.5012>, case 1: <D.5015>, case 2: <D.5017>>
      <D.5012>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (32);
        if (beginning == 0B) goto <D.5253>; else goto <D.5254>;
        <D.5253>:
        D.5226 = -1;
        return D.5226;
        <D.5254>:
        beginning->ld_tag = 1;
        beginning->ld_size = size;
        beginning->ld_nelements = 1;
        D.5255 = *simple_d;
        beginning->ld_descriptor = D.5255;
        D.5256 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.5256;
        goto <D.5014>;
      }
      <D.5015>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (32);
        if (beginning == 0B) goto <D.5257>; else goto <D.5258>;
        <D.5257>:
        D.5226 = -1;
        return D.5226;
        <D.5258>:
        beginning->ld_tag = 1;
        D.5259 = leaf->ld_size;
        beginning->ld_size = D.5259;
        D.5260 = leaf->ld_nelements;
        beginning->ld_nelements = D.5260;
        D.5261 = leaf->ld_descriptor;
        beginning->ld_descriptor = D.5261;
        D.5262 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.5262;
        goto <D.5014>;
      }
      <D.5017>:
      D.5263 = *complex_d;
      D.5264 = GC_make_sequence_descriptor (D.5263, one_element);
      *complex_d = D.5264;
      goto <D.5014>;
      <D.5265>:
      <D.5014>:
      D.5226 = 2;
      return D.5226;
    }
  }
  <D.5242>:
  <D.5239>:
  <D.5237>:
  <D.5235>:
  leaf->ld_size = size;
  leaf->ld_nelements = nelements;
  leaf->ld_descriptor = descriptor;
  D.5226 = 1;
  return D.5226;
}


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

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


GC_init_explicit_typing ()
{
  int D.5271;
  int GC_explicit_typing_initialized.4;
  void * * D.5277;
  char * * GC_eobjfreelist.5;
  int D.5279;
  int D.5280;
  void * * D.5281;
  int D.5282;
  char * * GC_arobjfreelist.6;
  int GC_array_mark_proc_index.7;
  int D.5285;
  int D.5286;
  long unsigned int D.5287;
  int D.5288;
  unsigned int i.8;
  unsigned int D.5290;
  long unsigned int D.5291;
  register int i;

  D.5271 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5271 != 0) goto <D.5272>; else goto <D.5273>;
  <D.5272>:
  GC_lock ();
  <D.5273>:
  GC_explicit_typing_initialized.4 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.4 != 0) goto <D.5275>; else goto <D.5276>;
  <D.5275>:
  pthread_mutex_unlock (&GC_allocate_ml);
  return;
  <D.5276>:
  GC_explicit_typing_initialized = 1;
  D.5277 = GC_new_free_list_inner ();
  GC_eobjfreelist = D.5277;
  GC_eobjfreelist.5 = GC_eobjfreelist;
  D.5279 = GC_new_kind_inner (GC_eobjfreelist.5, 18446744073709551611, 1, 1);
  GC_explicit_kind = D.5279;
  D.5280 = GC_new_proc_inner (GC_typed_mark_proc);
  GC_typed_mark_proc_index = D.5280;
  D.5281 = GC_new_free_list_inner ();
  GC_arobjfreelist = D.5281;
  D.5282 = GC_new_proc_inner (GC_array_mark_proc);
  GC_array_mark_proc_index = D.5282;
  GC_arobjfreelist.6 = GC_arobjfreelist;
  GC_array_mark_proc_index.7 = GC_array_mark_proc_index;
  D.5285 = GC_array_mark_proc_index.7 << 2;
  D.5286 = D.5285 | 2;
  D.5287 = (long unsigned int) D.5286;
  D.5288 = GC_new_kind_inner (GC_arobjfreelist.6, D.5287, 0, 1);
  GC_array_kind = D.5288;
  i = 0;
  goto <D.5040>;
  <D.5039>:
  {
    GC_descr d;

    i.8 = (unsigned int) i;
    D.5290 = 64 - i.8;
    D.5291 = 18446744073709551615 >> D.5290;
    i.8 = (unsigned int) i;
    D.5290 = 64 - i.8;
    d = D.5291 << D.5290;
    d = d | 1;
    GC_bm_table[i] = d;
  }
  i = i + 1;
  <D.5040>:
  i.8 = (unsigned int) i;
  if (i.8 <= 31) goto <D.5039>; else goto <D.5041>;
  <D.5041>:
  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.9;
  long unsigned int D.5294;
  struct ext_descr * D.5295;
  long unsigned int D.5296;
  char * current.10;
  long unsigned int my_current.11;
  long unsigned int D.5305;
  long unsigned int D.5306;
  struct bottom_index * D.5308;
  long unsigned int D.5309;
  long unsigned int D.5310;
  long unsigned int my_hhdr.12;
  struct hdr * GC_invalid_header.13;
  long int my_current.14;
  int D.5316;
  map_entry_type * D.5317;
  sizetype D.5318;
  map_entry_type * D.5319;
  unsigned char D.5320;
  long unsigned int D.5325;
  long unsigned int D.5326;
  long unsigned int D.5327;
  long unsigned int D.5328;
  int GC_all_interior_pointers.15;
  word[8] * D.5340;
  int D.5341;
  long unsigned int D.5342;
  long unsigned int D.5343;
  int D.5344;
  long unsigned int D.5345;
  long unsigned int D.5347;
  int D.5348;
  long unsigned int D.5354;
  long unsigned int D.5355;
  sizetype my_current.16;
  sizetype D.5357;
  sizetype D.5358;
  GC_word * D.5359;
  int D.5360;
  word * D.5365;
  long unsigned int D.5366;
  long unsigned int D.5367;
  int GC_typed_mark_proc_index.17;
  long unsigned int D.5369;
  long unsigned int D.5370;
  long unsigned int D.5371;
  long unsigned int D.5372;
  struct mse * D.5373;
  register word bm;
  register word * current_p;
  register word current;
  register char * greatest_ha;
  register char * least_ha;
  void exit1 = <<< error >>>;

  GC_ext_descriptors.9 = GC_ext_descriptors;
  D.5294 = env * 16;
  D.5295 = GC_ext_descriptors.9 + D.5294;
  bm = D.5295->ed_bitmap;
  current_p = addr;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  goto <D.5073>;
  <D.5072>:
  D.5296 = bm & 1;
  if (D.5296 != 0) goto <D.5297>; else goto <D.5298>;
  <D.5297>:
  current = *current_p;
  current.10 = (char *) current;
  if (current.10 >= least_ha) goto <D.5300>; else goto <D.5301>;
  <D.5300>:
  current.10 = (char *) current;
  if (current.10 <= greatest_ha) goto <D.5302>; else goto <D.5303>;
  <D.5302>:
  {
    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.11 = (long unsigned int) my_current;
          hi = my_current.11 >> 22;
          D.5305 = hi & 2047;
          _bi = GC_arrays._top_index[D.5305];
          goto <D.5060>;
          <D.5059>:
          _bi = _bi->hash_link;
          <D.5060>:
          D.5306 = _bi->key;
          if (D.5306 != hi) goto <D.5307>; else goto <D.5061>;
          <D.5307>:
          D.5308 = GC_arrays._all_nils;
          if (D.5308 != _bi) goto <D.5059>; else goto <D.5061>;
          <D.5061>:
          bi = _bi;
        }
        my_current.11 = (long unsigned int) my_current;
        D.5309 = my_current.11 >> 12;
        D.5310 = D.5309 & 1023;
        _ha = &bi->index[D.5310];
      }
      my_hhdr = *_ha;
    }
    my_hhdr.12 = (long unsigned int) my_hhdr;
    if (my_hhdr.12 <= 4095) goto <D.5312>; else goto <D.5313>;
    <D.5312>:
    {
      struct hdr * new_hdr;

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

      my_current.14 = (long int) my_current;
      D.5316 = (int) my_current.14;
      displ = D.5316 & 4095;
      D.5317 = my_hhdr->hb_map;
      D.5318 = (sizetype) displ;
      D.5319 = D.5317 + D.5318;
      D.5320 = *D.5319;
      map_entry = (int) D.5320;
      displ = displ >> 3;
      if (map_entry > 253) goto <D.5321>; else goto <D.5322>;
      <D.5321>:
      if (map_entry == 254) goto <D.5323>; else goto <D.5324>;
      <D.5323>:
      D.5325 = (long unsigned int) displ;
      D.5326 = my_hhdr->hb_sz;
      D.5327 = D.5325 % D.5326;
      map_entry = (int) D.5327;
      displ = displ - map_entry;
      D.5325 = (long unsigned int) displ;
      D.5326 = my_hhdr->hb_sz;
      D.5328 = D.5325 + D.5326;
      if (D.5328 > 512) goto <D.5329>; else goto <D.5330>;
      <D.5329>:
      GC_all_interior_pointers.15 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.15 != 0) goto <D.5332>; else goto <D.5333>;
      <D.5332>:
      my_current.11 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.11);
      goto <D.5334>;
      <D.5333>:
      my_current.11 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.11);
      <D.5334>:
      goto exit1;
      <D.5330>:
      goto <D.5335>;
      <D.5324>:
      GC_all_interior_pointers.15 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.15 != 0) goto <D.5336>; else goto <D.5337>;
      <D.5336>:
      my_current.11 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.11);
      goto <D.5338>;
      <D.5337>:
      my_current.11 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.11);
      <D.5338>:
      goto exit1;
      <D.5335>:
      goto <D.5339>;
      <D.5322>:
      displ = displ - map_entry;
      <D.5339>:
      {
        register word * mark_word_addr;

        D.5340 = &my_hhdr->hb_marks;
        D.5341 = displ >> 6;
        D.5342 = (long unsigned int) D.5341;
        D.5343 = D.5342 * 8;
        mark_word_addr = D.5340 + D.5343;
        {
          word old;
          word my_bits;

          D.5344 = displ & 63;
          my_bits = 1 << D.5344;
          <D.5069>:
          old = MEM[(volatile word *)mark_word_addr];
          D.5345 = old & my_bits;
          if (D.5345 != 0) goto exit1; else goto <D.5346>;
          <D.5346>:
          D.5347 = old | my_bits;
          D.5348 = GC_compare_and_exchange (mark_word_addr, old, D.5347);
          if (D.5348 == 0) goto <D.5069>; else goto <D.5070>;
          <D.5070>:
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.5349>; else goto <D.5350>;
        <D.5349>:
        goto <D.5351>;
        <D.5350>:
        mark_stack_ptr = mark_stack_ptr + 16;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.5352>; else goto <D.5353>;
        <D.5352>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.5353>:
        D.5354 = (long unsigned int) displ;
        D.5355 = D.5354 * 8;
        my_current.16 = (sizetype) my_current;
        D.5357 = my_current.16 & 18446744073709547520;
        D.5358 = D.5355 + D.5357;
        D.5359 = (GC_word *) D.5358;
        mark_stack_ptr->mse_start = D.5359;
        mark_stack_ptr->mse_descr = _descr;
        <D.5351>:
      }
    }
    exit1:
  }
  <D.5303>:
  <D.5301>:
  <D.5298>:
  bm = bm >> 1;
  current_p = current_p + 8;
  <D.5073>:
  if (bm != 0) goto <D.5072>; else goto <D.5074>;
  <D.5074>:
  GC_ext_descriptors.9 = GC_ext_descriptors;
  D.5294 = env * 16;
  D.5295 = GC_ext_descriptors.9 + D.5294;
  D.5360 = D.5295->ed_continued;
  if (D.5360 != 0) goto <D.5361>; else goto <D.5362>;
  <D.5361>:
  mark_stack_ptr = mark_stack_ptr + 16;
  if (mark_stack_ptr >= mark_stack_limit) goto <D.5363>; else goto <D.5364>;
  <D.5363>:
  mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
  <D.5364>:
  D.5365 = addr + 512;
  mark_stack_ptr->mse_start = D.5365;
  D.5366 = env + 1;
  D.5367 = D.5366 << 6;
  GC_typed_mark_proc_index.17 = GC_typed_mark_proc_index;
  D.5369 = (long unsigned int) GC_typed_mark_proc_index.17;
  D.5370 = D.5367 | D.5369;
  D.5371 = D.5370 << 2;
  D.5372 = D.5371 | 2;
  mark_stack_ptr->mse_descr = D.5372;
  <D.5362>:
  D.5373 = mark_stack_ptr;
  return D.5373;
}


GC_compare_and_exchange (volatile GC_word * addr, GC_word old, GC_word new_val)
{
  GC_bool D.5375;
  _Bool D.5376;
  int retval;

  __asm__ __volatile__("     csg %1,%2,0(%3)
     ipm %0
     srl %0,28
" : "=&d" retval, "=d" old : "d" new_val, "a" addr, "1" old : "memory", "cc");
  D.5376 = retval == 0;
  D.5375 = (GC_bool) D.5376;
  return D.5375;
}


GC_descr_obj_size (union complex_descriptor * d)
{
  long unsigned int D.5378;
  word D.5379;
  long unsigned int D.5380;
  long unsigned int D.5381;
  long unsigned int D.5382;
  union ComplexDescriptor * D.5383;
  long unsigned int D.5384;
  union ComplexDescriptor * D.5385;
  long unsigned int D.5386;
  union ComplexDescriptor * D.5387;
  long unsigned int D.5388;

  D.5378 = d->ld.ld_tag;
  switch (D.5378) <default: <D.5081>, case 1: <D.5078>, case 2: <D.5079>, case 3: <D.5080>>
  <D.5078>:
  D.5380 = d->ld.ld_nelements;
  D.5381 = d->ld.ld_size;
  D.5379 = D.5380 * D.5381;
  return D.5379;
  <D.5079>:
  D.5382 = d->ad.ad_nelements;
  D.5383 = d->ad.ad_element_descr;
  D.5384 = GC_descr_obj_size (D.5383);
  D.5379 = D.5382 * D.5384;
  return D.5379;
  <D.5080>:
  D.5385 = d->sd.sd_first;
  D.5386 = GC_descr_obj_size (D.5385);
  D.5387 = d->sd.sd_second;
  D.5388 = GC_descr_obj_size (D.5387);
  D.5379 = D.5386 + D.5388;
  return D.5379;
  <D.5081>:
  GC_abort ("Bad complex descriptor");
  D.5379 = 0;
  return D.5379;
}


GC_push_complex_descriptor (word * addr, union complex_descriptor * d, struct mse * msp, struct mse * msl)
{
  long unsigned int D.5390;
  long int msl.18;
  long int msp.19;
  long int D.5393;
  long int D.5394;
  long int nelements.20;
  struct mse * D.5398;
  union ComplexDescriptor * D.5401;
  union ComplexDescriptor * D.5404;
  register char * current;
  register word nelements;
  register word sz;
  register word i;

  current = addr;
  D.5390 = d->ld.ld_tag;
  switch (D.5390) <default: <D.5103>, case 1: <D.5092>, case 2: <D.5097>, case 3: <D.5102>>
  <D.5092>:
  {
    register GC_descr descr;

    descr = d->ld.ld_descriptor;
    nelements = d->ld.ld_nelements;
    msl.18 = (long int) msl;
    msp.19 = (long int) msp;
    D.5393 = msl.18 - msp.19;
    D.5394 = D.5393 /[ex] 16;
    nelements.20 = (long int) nelements;
    if (D.5394 <= nelements.20) goto <D.5396>; else goto <D.5397>;
    <D.5396>:
    D.5398 = 0B;
    return D.5398;
    <D.5397>:
    sz = d->ld.ld_size;
    i = 0;
    goto <D.5095>;
    <D.5094>:
    msp = msp + 16;
    msp->mse_start = current;
    msp->mse_descr = descr;
    current = current + sz;
    i = i + 1;
    <D.5095>:
    if (i < nelements) goto <D.5094>; else goto <D.5096>;
    <D.5096>:
    D.5398 = msp;
    return D.5398;
  }
  <D.5097>:
  {
    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.5100>;
    <D.5099>:
    msp = GC_push_complex_descriptor (current, descr, msp, msl);
    if (msp == 0B) goto <D.5399>; else goto <D.5400>;
    <D.5399>:
    D.5398 = 0B;
    return D.5398;
    <D.5400>:
    current = current + sz;
    i = i + 1;
    <D.5100>:
    if (i < nelements) goto <D.5099>; else goto <D.5101>;
    <D.5101>:
    D.5398 = msp;
    return D.5398;
  }
  <D.5102>:
  D.5401 = d->sd.sd_first;
  sz = GC_descr_obj_size (D.5401);
  D.5401 = d->sd.sd_first;
  msp = GC_push_complex_descriptor (current, D.5401, msp, msl);
  if (msp == 0B) goto <D.5402>; else goto <D.5403>;
  <D.5402>:
  D.5398 = 0B;
  return D.5398;
  <D.5403>:
  current = current + sz;
  D.5404 = d->sd.sd_second;
  msp = GC_push_complex_descriptor (current, D.5404, msp, msl);
  D.5398 = msp;
  return D.5398;
  <D.5103>:
  GC_abort ("Bad complex descriptor");
  D.5398 = 0B;
  return D.5398;
}


GC_array_mark_proc (word * addr, struct mse * mark_stack_ptr, struct mse * mark_stack_limit, word env)
{
  long unsigned int D.5406;
  sizetype D.5407;
  word * D.5408;
  long unsigned int D.5409;
  struct mse * D.5412;
  struct mse * D.5413;
  long unsigned int D.5416;
  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.5406 = sz * 8;
  D.5407 = D.5406 + 18446744073709551608;
  D.5408 = addr + D.5407;
  D.5409 = *D.5408;
  descr = (union complex_descriptor *) D.5409;
  orig_mark_stack_ptr = mark_stack_ptr;
  if (descr == 0B) goto <D.5410>; else goto <D.5411>;
  <D.5410>:
  D.5412 = orig_mark_stack_ptr;
  return D.5412;
  <D.5411>:
  D.5413 = mark_stack_limit + 18446744073709551600;
  new_mark_stack_ptr = GC_push_complex_descriptor (addr, descr, mark_stack_ptr, D.5413);
  if (new_mark_stack_ptr == 0B) goto <D.5414>; else goto <D.5415>;
  <D.5414>:
  GC_mark_stack_too_small = 1;
  new_mark_stack_ptr = orig_mark_stack_ptr + 16;
  new_mark_stack_ptr->mse_start = addr;
  D.5416 = sz << 3;
  new_mark_stack_ptr->mse_descr = D.5416;
  goto <D.5417>;
  <D.5415>:
  new_mark_stack_ptr = new_mark_stack_ptr + 16;
  D.5406 = sz * 8;
  D.5407 = D.5406 + 18446744073709551608;
  D.5408 = addr + D.5407;
  new_mark_stack_ptr->mse_start = D.5408;
  new_mark_stack_ptr->mse_descr = 8;
  <D.5417>:
  D.5412 = new_mark_stack_ptr;
  return D.5412;
}


GC_make_descriptor (GC_word * bm, size_t len)
{
  long unsigned int D.5419;
  int GC_explicit_typing_initialized.21;
  long unsigned int last_set_bit.22;
  long unsigned int D.5425;
  long unsigned int D.5426;
  GC_word * D.5427;
  long unsigned int D.5428;
  unsigned int D.5429;
  unsigned int D.5430;
  long unsigned int D.5431;
  long unsigned int D.5432;
  GC_descr D.5435;
  long unsigned int D.5436;
  long unsigned int D.5437;
  long unsigned int D.5438;
  GC_word * D.5439;
  long unsigned int D.5440;
  unsigned int i.23;
  unsigned int D.5442;
  long unsigned int D.5443;
  long unsigned int D.5444;
  long int D.5447;
  long int D.5450;
  long int D.5451;
  unsigned int D.5454;
  unsigned int D.5455;
  long unsigned int D.5458;
  long unsigned int index.24;
  long unsigned int D.5462;
  int GC_typed_mark_proc_index.25;
  long unsigned int D.5464;
  long unsigned int D.5465;
  long unsigned int D.5466;
  register signed_word last_set_bit;
  register word result;
  register int i;

  D.5419 = len + 18446744073709551615;
  last_set_bit = (signed_word) D.5419;
  GC_explicit_typing_initialized.21 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.21 == 0) goto <D.5421>; else goto <D.5422>;
  <D.5421>:
  GC_init_explicit_typing ();
  <D.5422>:
  goto <D.5123>;
  <D.5122>:
  last_set_bit = last_set_bit + -1;
  <D.5123>:
  if (last_set_bit >= 0) goto <D.5423>; else goto <D.5124>;
  <D.5423>:
  last_set_bit.22 = (long unsigned int) last_set_bit;
  D.5425 = last_set_bit.22 / 64;
  D.5426 = D.5425 * 8;
  D.5427 = bm + D.5426;
  D.5428 = *D.5427;
  D.5429 = (unsigned int) last_set_bit;
  D.5430 = D.5429 & 63;
  D.5431 = D.5428 >> D.5430;
  D.5432 = D.5431 & 1;
  if (D.5432 == 0) goto <D.5122>; else goto <D.5124>;
  <D.5124>:
  if (last_set_bit < 0) goto <D.5433>; else goto <D.5434>;
  <D.5433>:
  D.5435 = 0;
  return D.5435;
  <D.5434>:
  {
    register GC_bool all_bits_set;

    all_bits_set = 1;
    i = 0;
    goto <D.5128>;
    <D.5127>:
    D.5436 = (long unsigned int) i;
    D.5437 = D.5436 / 64;
    D.5438 = D.5437 * 8;
    D.5439 = bm + D.5438;
    D.5440 = *D.5439;
    i.23 = (unsigned int) i;
    D.5442 = i.23 & 63;
    D.5443 = D.5440 >> D.5442;
    D.5444 = D.5443 & 1;
    if (D.5444 == 0) goto <D.5445>; else goto <D.5446>;
    <D.5445>:
    all_bits_set = 0;
    goto <D.5126>;
    <D.5446>:
    i = i + 1;
    <D.5128>:
    D.5447 = (long int) i;
    if (D.5447 < last_set_bit) goto <D.5127>; else goto <D.5126>;
    <D.5126>:
    if (all_bits_set != 0) goto <D.5448>; else goto <D.5449>;
    <D.5448>:
    D.5450 = last_set_bit + 1;
    D.5451 = D.5450 << 3;
    D.5435 = (GC_descr) D.5451;
    return D.5435;
    <D.5449>:
  }
  last_set_bit.22 = (long unsigned int) last_set_bit;
  if (last_set_bit.22 <= 61) goto <D.5452>; else goto <D.5453>;
  <D.5452>:
  result = 9223372036854775808;
  D.5454 = (unsigned int) last_set_bit;
  D.5455 = D.5454 + 4294967295;
  i = (int) D.5455;
  goto <D.5130>;
  <D.5129>:
  result = result >> 1;
  D.5436 = (long unsigned int) i;
  D.5437 = D.5436 / 64;
  D.5438 = D.5437 * 8;
  D.5439 = bm + D.5438;
  D.5440 = *D.5439;
  i.23 = (unsigned int) i;
  D.5442 = i.23 & 63;
  D.5443 = D.5440 >> D.5442;
  D.5444 = D.5443 & 1;
  if (D.5444 != 0) goto <D.5456>; else goto <D.5457>;
  <D.5456>:
  result = result | 9223372036854775808;
  <D.5457>:
  i = i + -1;
  <D.5130>:
  if (i >= 0) goto <D.5129>; else goto <D.5131>;
  <D.5131>:
  result = result | 1;
  D.5435 = result;
  return D.5435;
  <D.5453>:
  {
    signed_word index;

    last_set_bit.22 = (long unsigned int) last_set_bit;
    D.5458 = last_set_bit.22 + 1;
    index = GC_add_ext_descriptor (bm, D.5458);
    if (index == -1) goto <D.5459>; else goto <D.5460>;
    <D.5459>:
    D.5450 = last_set_bit + 1;
    D.5451 = D.5450 << 3;
    D.5435 = (GC_descr) D.5451;
    return D.5435;
    <D.5460>:
    index.24 = (long unsigned int) index;
    D.5462 = index.24 << 6;
    GC_typed_mark_proc_index.25 = GC_typed_mark_proc_index;
    D.5464 = (long unsigned int) GC_typed_mark_proc_index.25;
    D.5465 = D.5462 | D.5464;
    D.5466 = D.5465 << 2;
    result = D.5466 | 2;
    D.5435 = result;
    return D.5435;
  }
}


GC_malloc_explicitly_typed (size_t lb, GC_descr d)
{
  int GC_all_interior_pointers.26;
  long unsigned int D.5469;
  long unsigned int D.5470;
  long unsigned int D.5471;
  unsigned int D.5474;
  char * * GC_eobjfreelist.27;
  long unsigned int D.5476;
  int D.5477;
  int GC_explicit_kind.28;
  char * D.5483;
  void * D.5486;
  char * D.5488;
  long unsigned int D.5489;
  long unsigned int D.5490;
  char * D.5492;
  long unsigned int D.5495;
  sizetype D.5498;
  word * D.5499;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.26 = GC_all_interior_pointers;
  D.5469 = (long unsigned int) GC_all_interior_pointers.26;
  D.5470 = lb - D.5469;
  lb = D.5470 + 8;
  GC_all_interior_pointers.26 = GC_all_interior_pointers;
  D.5469 = (long unsigned int) GC_all_interior_pointers.26;
  D.5471 = 2048 - D.5469;
  if (D.5471 >= lb) goto <D.5472>; else goto <D.5473>;
  <D.5472>:
  D.5474 = GC_arrays._size_map[lb];
  lw = (word) D.5474;
  GC_eobjfreelist.27 = GC_eobjfreelist;
  D.5476 = lw * 8;
  opp = GC_eobjfreelist.27 + D.5476;
  D.5477 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5477 != 0) goto <D.5478>; else goto <D.5479>;
  <D.5478>:
  GC_lock ();
  <D.5479>:
  op = *opp;
  if (op == 0B) goto <D.5480>; else goto <D.5481>;
  <D.5480>:
  pthread_mutex_unlock (&GC_allocate_ml);
  GC_explicit_kind.28 = GC_explicit_kind;
  D.5483 = GC_generic_malloc (lb, GC_explicit_kind.28);
  op = GC_clear_stack (D.5483);
  if (op == 0B) goto <D.5484>; else goto <D.5485>;
  <D.5484>:
  D.5486 = 0B;
  return D.5486;
  <D.5485>:
  D.5474 = GC_arrays._size_map[lb];
  lw = (word) D.5474;
  goto <D.5487>;
  <D.5481>:
  D.5488 = MEM[(char * *)op];
  *opp = D.5488;
  MEM[(char * *)op] = 0B;
  D.5489 = GC_arrays._words_allocd;
  D.5490 = D.5489 + lw;
  GC_arrays._words_allocd = D.5490;
  pthread_mutex_unlock (&GC_allocate_ml);
  <D.5487>:
  goto <D.5491>;
  <D.5473>:
  GC_explicit_kind.28 = GC_explicit_kind;
  D.5492 = GC_generic_malloc (lb, GC_explicit_kind.28);
  op = GC_clear_stack (D.5492);
  if (op != 0B) goto <D.5493>; else goto <D.5494>;
  <D.5493>:
  D.5495 = GC_size (op);
  lw = D.5495 >> 3;
  <D.5494>:
  <D.5491>:
  if (op != 0B) goto <D.5496>; else goto <D.5497>;
  <D.5496>:
  D.5476 = lw * 8;
  D.5498 = D.5476 + 18446744073709551608;
  D.5499 = op + D.5498;
  *D.5499 = d;
  <D.5497>:
  D.5486 = op;
  return D.5486;
}


GC_malloc_explicitly_typed_ignore_off_page (size_t lb, GC_descr d)
{
  int GC_all_interior_pointers.29;
  long unsigned int D.5502;
  long unsigned int D.5503;
  long unsigned int D.5504;
  unsigned int D.5507;
  char * * GC_eobjfreelist.30;
  long unsigned int D.5509;
  int D.5510;
  int GC_explicit_kind.31;
  char * D.5516;
  char * D.5518;
  long unsigned int D.5519;
  long unsigned int D.5520;
  char * D.5522;
  long unsigned int D.5525;
  sizetype D.5528;
  word * D.5529;
  void * D.5530;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.29 = GC_all_interior_pointers;
  D.5502 = (long unsigned int) GC_all_interior_pointers.29;
  D.5503 = lb - D.5502;
  lb = D.5503 + 8;
  GC_all_interior_pointers.29 = GC_all_interior_pointers;
  D.5502 = (long unsigned int) GC_all_interior_pointers.29;
  D.5504 = 2048 - D.5502;
  if (D.5504 >= lb) goto <D.5505>; else goto <D.5506>;
  <D.5505>:
  D.5507 = GC_arrays._size_map[lb];
  lw = (word) D.5507;
  GC_eobjfreelist.30 = GC_eobjfreelist;
  D.5509 = lw * 8;
  opp = GC_eobjfreelist.30 + D.5509;
  D.5510 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5510 != 0) goto <D.5511>; else goto <D.5512>;
  <D.5511>:
  GC_lock ();
  <D.5512>:
  op = *opp;
  if (op == 0B) goto <D.5513>; else goto <D.5514>;
  <D.5513>:
  pthread_mutex_unlock (&GC_allocate_ml);
  GC_explicit_kind.31 = GC_explicit_kind;
  D.5516 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.31);
  op = GC_clear_stack (D.5516);
  D.5507 = GC_arrays._size_map[lb];
  lw = (word) D.5507;
  goto <D.5517>;
  <D.5514>:
  D.5518 = MEM[(char * *)op];
  *opp = D.5518;
  MEM[(char * *)op] = 0B;
  D.5519 = GC_arrays._words_allocd;
  D.5520 = D.5519 + lw;
  GC_arrays._words_allocd = D.5520;
  pthread_mutex_unlock (&GC_allocate_ml);
  <D.5517>:
  goto <D.5521>;
  <D.5506>:
  GC_explicit_kind.31 = GC_explicit_kind;
  D.5522 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.31);
  op = GC_clear_stack (D.5522);
  if (op != 0B) goto <D.5523>; else goto <D.5524>;
  <D.5523>:
  D.5525 = GC_size (op);
  lw = D.5525 >> 3;
  <D.5524>:
  <D.5521>:
  if (op != 0B) goto <D.5526>; else goto <D.5527>;
  <D.5526>:
  D.5509 = lw * 8;
  D.5528 = D.5509 + 18446744073709551608;
  D.5529 = op + D.5528;
  *D.5529 = d;
  <D.5527>:
  D.5530 = op;
  return D.5530;
}


GC_calloc_explicitly_typed (size_t n, size_t lb, GC_descr d)
{
  void * D.5532;
  long unsigned int D.5533;
  long unsigned int simple_descr.32;
  int GC_all_interior_pointers.33;
  long unsigned int D.5536;
  long unsigned int D.5537;
  long unsigned int D.5539;
  unsigned int D.5542;
  char * * GC_arobjfreelist.34;
  long unsigned int D.5544;
  int D.5545;
  int GC_array_kind.35;
  char * D.5551;
  char * D.5555;
  long unsigned int D.5556;
  long unsigned int D.5557;
  char * D.5559;
  long unsigned int D.5562;
  sizetype D.5565;
  long unsigned int D.5566;
  long unsigned int D.5567;
  long unsigned int D.5568;
  sizetype D.5569;
  volatile word * D.5570;
  long unsigned int lp.36;
  word * D.5573;
  union complex_descriptor * complex_descr.37;
  long unsigned int complex_descr.38;
  void * * D.5576;
  unsigned int GC_finalization_failures.39;
  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.5538>, case -1: <D.5160>, case 0: <D.5161>, case 1: <D.5162>, case 2: <D.5164>>
      <D.5160>:
      D.5532 = 0B;
      return D.5532;
      <D.5161>:
      D.5533 = n * lb;
      simple_descr.32 = simple_descr;
      D.5532 = GC_malloc_explicitly_typed (D.5533, simple_descr.32);
      return D.5532;
      <D.5162>:
      lb = lb * n;
      GC_all_interior_pointers.33 = GC_all_interior_pointers;
      D.5536 = (long unsigned int) GC_all_interior_pointers.33;
      D.5537 = lb - D.5536;
      lb = D.5537 + 40;
      goto <D.5163>;
      <D.5164>:
      lb = lb * n;
      GC_all_interior_pointers.33 = GC_all_interior_pointers;
      D.5536 = (long unsigned int) GC_all_interior_pointers.33;
      D.5537 = lb - D.5536;
      lb = D.5537 + 8;
      goto <D.5163>;
      <D.5538>:
      <D.5163>:
      GC_all_interior_pointers.33 = GC_all_interior_pointers;
      D.5536 = (long unsigned int) GC_all_interior_pointers.33;
      D.5539 = 2048 - D.5536;
      if (D.5539 >= lb) goto <D.5540>; else goto <D.5541>;
      <D.5540>:
      D.5542 = GC_arrays._size_map[lb];
      lw = (word) D.5542;
      GC_arobjfreelist.34 = GC_arobjfreelist;
      D.5544 = lw * 8;
      opp = GC_arobjfreelist.34 + D.5544;
      D.5545 = pthread_mutex_trylock (&GC_allocate_ml);
      if (D.5545 != 0) goto <D.5546>; else goto <D.5547>;
      <D.5546>:
      GC_lock ();
      <D.5547>:
      op = *opp;
      if (op == 0B) goto <D.5548>; else goto <D.5549>;
      <D.5548>:
      pthread_mutex_unlock (&GC_allocate_ml);
      GC_array_kind.35 = GC_array_kind;
      D.5551 = GC_generic_malloc (lb, GC_array_kind.35);
      op = GC_clear_stack (D.5551);
      if (op == 0B) goto <D.5552>; else goto <D.5553>;
      <D.5552>:
      D.5532 = 0B;
      return D.5532;
      <D.5553>:
      D.5542 = GC_arrays._size_map[lb];
      lw = (word) D.5542;
      goto <D.5554>;
      <D.5549>:
      D.5555 = MEM[(char * *)op];
      *opp = D.5555;
      MEM[(char * *)op] = 0B;
      D.5556 = GC_arrays._words_allocd;
      D.5557 = D.5556 + lw;
      GC_arrays._words_allocd = D.5557;
      pthread_mutex_unlock (&GC_allocate_ml);
      <D.5554>:
      goto <D.5558>;
      <D.5541>:
      GC_array_kind.35 = GC_array_kind;
      D.5559 = GC_generic_malloc (lb, GC_array_kind.35);
      op = GC_clear_stack (D.5559);
      if (op == 0B) goto <D.5560>; else goto <D.5561>;
      <D.5560>:
      D.5532 = 0B;
      return D.5532;
      <D.5561>:
      D.5562 = GC_size (op);
      lw = D.5562 >> 3;
      <D.5558>:
      if (descr_type == 1) goto <D.5563>; else goto <D.5564>;
      <D.5563>:
      {
        volatile struct LeafDescriptor * lp;

        D.5544 = lw * 8;
        D.5565 = D.5544 + 18446744073709551576;
        lp = op + D.5565;
        lp->ld_tag = 1;
        D.5566 = leaf.ld_size;
        lp->ld_size = D.5566;
        D.5567 = leaf.ld_nelements;
        lp->ld_nelements = D.5567;
        D.5568 = leaf.ld_descriptor;
        lp->ld_descriptor = D.5568;
        D.5544 = lw * 8;
        D.5569 = D.5544 + 18446744073709551608;
        D.5570 = op + D.5569;
        lp.36 = (long unsigned int) lp;
        *D.5570 = lp.36;
      }
      goto <D.5572>;
      <D.5564>:
      {
        extern unsigned int GC_finalization_failures;
        unsigned int ff;

        ff = GC_finalization_failures;
        D.5544 = lw * 8;
        D.5569 = D.5544 + 18446744073709551608;
        D.5573 = op + D.5569;
        complex_descr.37 = complex_descr;
        complex_descr.38 = (long unsigned int) complex_descr.37;
        *D.5573 = complex_descr.38;
        D.5544 = lw * 8;
        D.5569 = D.5544 + 18446744073709551608;
        D.5576 = op + D.5569;
        GC_general_register_disappearing_link (D.5576, op);
        GC_finalization_failures.39 = GC_finalization_failures;
        if (ff != GC_finalization_failures.39) goto <D.5578>; else goto <D.5579>;
        <D.5578>:
        D.5533 = n * lb;
        D.5532 = GC_malloc (D.5533);
        return D.5532;
        <D.5579>:
      }
      <D.5572>:
      D.5532 = op;
      return D.5532;
    }
  finally
    {
      simple_descr = {CLOBBER};
      complex_descr = {CLOBBER};
      leaf = {CLOBBER};
    }
}