GC_add_ext_descriptor (GC_word * bm, word nbits)
{
  long unsigned int D.7237;
  int D.7238;
  signed_word D.7246;
  unsigned int D.7247;
  int D.7250;
  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.7260;
  long unsigned int GC_avail_descr.4;
  long unsigned int result.3;
  long unsigned int D.7263;
  long unsigned int D.7264;
  struct ext_descr * D.7265;
  long unsigned int D.7266;
  GC_word * D.7267;
  long unsigned int D.7268;
  unsigned int D.7269;
  long unsigned int D.7270;
  long unsigned int D.7271;
  register size_t nwords;
  register signed_word result;
  register word i;
  register word last_part;
  register int extra_bits;

  D.7237 = nbits + 31;
  nwords = D.7237 >> 5;
  D.7238 = GC_test_and_set (&GC_allocate_lock);
  if (D.7238 != 0) goto <D.7239>; else goto <D.7240>;
  <D.7239>:
  GC_lock ();
  <D.7240>:
  goto <D.7065>;
  <D.7064>:
  {
    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.7241>; else goto <D.7242>;
    <D.7241>:
    new_size = 100;
    goto <D.7243>;
    <D.7242>:
    new_size = ed_size * 2;
    if (new_size > 16777215) goto <D.7244>; else goto <D.7245>;
    <D.7244>:
    D.7246 = -1;
    return D.7246;
    <D.7245>:
    <D.7243>:
    D.7247 = new_size * 8;
    new = GC_malloc_atomic (D.7247);
    if (new == 0B) goto <D.7248>; else goto <D.7249>;
    <D.7248>:
    D.7246 = -1;
    return D.7246;
    <D.7249>:
    D.7250 = GC_test_and_set (&GC_allocate_lock);
    if (D.7250 != 0) goto <D.7251>; else goto <D.7252>;
    <D.7251>:
    GC_lock ();
    <D.7252>:
    GC_ed_size.0 = GC_ed_size;
    if (ed_size == GC_ed_size.0) goto <D.7254>; else goto <D.7255>;
    <D.7254>:
    GC_avail_descr.1 = GC_avail_descr;
    if (GC_avail_descr.1 != 0) goto <D.7257>; else goto <D.7258>;
    <D.7257>:
    GC_ext_descriptors.2 = GC_ext_descriptors;
    GC_avail_descr.1 = GC_avail_descr;
    D.7260 = GC_avail_descr.1 * 8;
    memcpy (new, GC_ext_descriptors.2, D.7260);
    <D.7258>:
    GC_ed_size = new_size;
    GC_ext_descriptors = new;
    <D.7255>:
  }
  <D.7065>:
  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.7064>; else goto <D.7066>;
  <D.7066>:
  GC_avail_descr.1 = GC_avail_descr;
  result = (signed_word) GC_avail_descr.1;
  i = 0;
  goto <D.7068>;
  <D.7067>:
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.7263 = result.3 + i;
  D.7264 = D.7263 * 8;
  D.7265 = GC_ext_descriptors.2 + D.7264;
  D.7266 = i * 4;
  D.7267 = bm + D.7266;
  D.7268 = *D.7267;
  D.7265->ed_bitmap = D.7268;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.7263 = result.3 + i;
  D.7264 = D.7263 * 8;
  D.7265 = GC_ext_descriptors.2 + D.7264;
  D.7265->ed_continued = 1;
  i = i + 1;
  <D.7068>:
  D.7269 = nwords + 4294967295;
  if (D.7269 > i) goto <D.7067>; else goto <D.7069>;
  <D.7069>:
  D.7266 = i * 4;
  D.7267 = bm + D.7266;
  last_part = *D.7267;
  D.7270 = nwords * 32;
  D.7271 = D.7270 - nbits;
  extra_bits = (int) D.7271;
  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.7263 = result.3 + i;
  D.7264 = D.7263 * 8;
  D.7265 = GC_ext_descriptors.2 + D.7264;
  D.7265->ed_bitmap = last_part;
  GC_ext_descriptors.2 = GC_ext_descriptors;
  result.3 = (long unsigned int) result;
  D.7263 = result.3 + i;
  D.7264 = D.7263 * 8;
  D.7265 = GC_ext_descriptors.2 + D.7264;
  D.7265->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.7246 = result;
  return D.7246;
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.7273;
  unsigned int D.7274;

  D.7274 = __sync_lock_test_and_set_4 (addr, 1);
  D.7273 = (int) D.7274;
  return D.7273;
}


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

  D.7277 = __builtin_object_size (__dest, 0);
  D.7276 = __builtin___memcpy_chk (__dest, __src, __len, D.7277);
  return D.7276;
}


GC_clear (volatile unsigned int * addr)
{
  __sync_synchronize ();
  *addr = 0;
}


GC_double_descr (GC_descr descriptor, word nwords)
{
  long unsigned int D.7279;
  long unsigned int D.7282;
  long unsigned int D.7283;
  int nwords.5;
  long unsigned int D.7285;
  GC_descr D.7286;

  D.7279 = descriptor & 3;
  if (D.7279 == 0) goto <D.7280>; else goto <D.7281>;
  <D.7280>:
  D.7282 = descriptor >> 2;
  descriptor = GC_bm_table[D.7282];
  <D.7281>:
  D.7283 = descriptor & 4294967292;
  nwords.5 = (int) nwords;
  D.7285 = D.7283 >> nwords.5;
  descriptor = D.7285 | descriptor;
  D.7286 = descriptor;
  return D.7286;
}


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.7288;
  long unsigned int D.7293;
  int D.7294;
  long unsigned int D.7308;
  long unsigned int D.7311;
  long unsigned int D.7312;
  long unsigned int D.7313;
  long unsigned int D.7314;
  long unsigned int D.7315;
  _Bool D.7318;
  _Bool D.7319;
  _Bool D.7320;
  long unsigned int D.7325;
  union complex_descriptor * D.7326;
  long unsigned int D.7329;
  long unsigned int D.7330;
  long unsigned int D.7331;
  union complex_descriptor * D.7332;
  union complex_descriptor * D.7333;
  union complex_descriptor * D.7334;

  D.7288 = descriptor & 3;
  if (D.7288 == 0) goto <D.7289>; else goto <D.7290>;
  <D.7289>:
  if (descriptor == size) goto <D.7291>; else goto <D.7292>;
  <D.7291>:
  D.7293 = nelements * descriptor;
  *simple_d = D.7293;
  D.7294 = 0;
  return D.7294;
  <D.7292>:
  if (descriptor == 0) goto <D.7295>; else goto <D.7296>;
  <D.7295>:
  *simple_d = 0;
  D.7294 = 0;
  return D.7294;
  <D.7296>:
  <D.7290>:
  if (nelements <= 50) goto <D.7297>; else goto <D.7298>;
  <D.7297>:
  if (nelements <= 1) goto <D.7299>; else goto <D.7300>;
  <D.7299>:
  if (nelements == 1) goto <D.7301>; else goto <D.7302>;
  <D.7301>:
  *simple_d = descriptor;
  D.7294 = 0;
  return D.7294;
  <D.7302>:
  *simple_d = 0;
  D.7294 = 0;
  return D.7294;
  <D.7300>:
  goto <D.7303>;
  <D.7298>:
  if (size <= 15) goto <D.7304>; else goto <D.7305>;
  <D.7304>:
  D.7288 = descriptor & 3;
  if (D.7288 != 2) goto <D.7306>; else goto <D.7307>;
  <D.7306>:
  D.7308 = size & 3;
  if (D.7308 == 0) goto <D.7309>; else goto <D.7310>;
  <D.7309>:
  {
    int result;

    D.7311 = nelements / 2;
    D.7312 = size * 2;
    D.7313 = size >> 2;
    D.7314 = GC_double_descr (descriptor, D.7313);
    result = GC_make_array_descriptor (D.7311, D.7312, D.7314, simple_d, complex_d, leaf);
    D.7315 = nelements & 1;
    if (D.7315 == 0) goto <D.7316>; else goto <D.7317>;
    <D.7316>:
    D.7294 = result;
    return D.7294;
    <D.7317>:
    {
      struct LeafDescriptor * one_element;

      one_element = GC_malloc_atomic (16);
      D.7318 = result == -1;
      D.7319 = one_element == 0B;
      D.7320 = D.7318 | D.7319;
      if (D.7320 != 0) goto <D.7321>; else goto <D.7322>;
      <D.7321>:
      D.7294 = -1;
      return D.7294;
      <D.7322>:
      one_element->ld_tag = 1;
      one_element->ld_size = size;
      one_element->ld_nelements = 1;
      one_element->ld_descriptor = descriptor;
      switch (result) <default: <D.7335>, case 0: <D.7086>, case 1: <D.7089>, case 2: <D.7091>>
      <D.7086>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (16);
        if (beginning == 0B) goto <D.7323>; else goto <D.7324>;
        <D.7323>:
        D.7294 = -1;
        return D.7294;
        <D.7324>:
        beginning->ld_tag = 1;
        beginning->ld_size = size;
        beginning->ld_nelements = 1;
        D.7325 = *simple_d;
        beginning->ld_descriptor = D.7325;
        D.7326 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.7326;
        goto <D.7088>;
      }
      <D.7089>:
      {
        struct LeafDescriptor * beginning;

        beginning = GC_malloc_atomic (16);
        if (beginning == 0B) goto <D.7327>; else goto <D.7328>;
        <D.7327>:
        D.7294 = -1;
        return D.7294;
        <D.7328>:
        beginning->ld_tag = 1;
        D.7329 = leaf->ld_size;
        beginning->ld_size = D.7329;
        D.7330 = leaf->ld_nelements;
        beginning->ld_nelements = D.7330;
        D.7331 = leaf->ld_descriptor;
        beginning->ld_descriptor = D.7331;
        D.7332 = GC_make_sequence_descriptor (beginning, one_element);
        *complex_d = D.7332;
        goto <D.7088>;
      }
      <D.7091>:
      D.7333 = *complex_d;
      D.7334 = GC_make_sequence_descriptor (D.7333, one_element);
      *complex_d = D.7334;
      goto <D.7088>;
      <D.7335>:
      <D.7088>:
      D.7294 = 2;
      return D.7294;
    }
  }
  <D.7310>:
  <D.7307>:
  <D.7305>:
  <D.7303>:
  leaf->ld_size = size;
  leaf->ld_nelements = nelements;
  leaf->ld_descriptor = descriptor;
  D.7294 = 1;
  return D.7294;
}


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

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


GC_init_explicit_typing ()
{
  int D.7341;
  int GC_explicit_typing_initialized.6;
  void * * GC_eobjfreelist.7;
  char * * GC_eobjfreelist.8;
  int GC_explicit_kind.9;
  int GC_typed_mark_proc_index.10;
  void * * GC_arobjfreelist.11;
  int GC_array_mark_proc_index.12;
  char * * GC_arobjfreelist.13;
  int GC_array_mark_proc_index.14;
  int D.7355;
  int D.7356;
  long unsigned int D.7357;
  int GC_array_kind.15;
  long unsigned int i.16;
  long unsigned int D.7360;
  int D.7361;
  long unsigned int D.7362;
  register int i;

  D.7341 = GC_test_and_set (&GC_allocate_lock);
  if (D.7341 != 0) goto <D.7342>; else goto <D.7343>;
  <D.7342>:
  GC_lock ();
  <D.7343>:
  GC_explicit_typing_initialized.6 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.6 != 0) goto <D.7345>; else goto <D.7346>;
  <D.7345>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.7346>:
  GC_explicit_typing_initialized = 1;
  GC_eobjfreelist.7 = GC_new_free_list_inner ();
  GC_eobjfreelist = GC_eobjfreelist.7;
  GC_eobjfreelist.8 = GC_eobjfreelist;
  GC_explicit_kind.9 = GC_new_kind_inner (GC_eobjfreelist.8, 4294967295, 1, 1);
  GC_explicit_kind = GC_explicit_kind.9;
  GC_typed_mark_proc_index.10 = GC_new_proc_inner (GC_typed_mark_proc);
  GC_typed_mark_proc_index = GC_typed_mark_proc_index.10;
  GC_arobjfreelist.11 = GC_new_free_list_inner ();
  GC_arobjfreelist = GC_arobjfreelist.11;
  GC_array_mark_proc_index.12 = GC_new_proc_inner (GC_array_mark_proc);
  GC_array_mark_proc_index = GC_array_mark_proc_index.12;
  GC_arobjfreelist.13 = GC_arobjfreelist;
  GC_array_mark_proc_index.14 = GC_array_mark_proc_index;
  D.7355 = GC_array_mark_proc_index.14 << 2;
  D.7356 = D.7355 | 2;
  D.7357 = (long unsigned int) D.7356;
  GC_array_kind.15 = GC_new_kind_inner (GC_arobjfreelist.13, D.7357, 0, 1);
  GC_array_kind = GC_array_kind.15;
  i = 0;
  goto <D.7114>;
  <D.7113>:
  {
    GC_descr d;

    i.16 = (long unsigned int) i;
    D.7360 = 32 - i.16;
    D.7361 = (int) D.7360;
    D.7362 = 4294967295 >> D.7361;
    i.16 = (long unsigned int) i;
    D.7360 = 32 - i.16;
    D.7361 = (int) D.7360;
    d = D.7362 << D.7361;
    d = d | 1;
    GC_bm_table[i] = d;
  }
  i = i + 1;
  <D.7114>:
  i.16 = (long unsigned int) i;
  if (i.16 <= 15) goto <D.7113>; else goto <D.7115>;
  <D.7115>:
  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.7365;
  struct ext_descr * D.7366;
  long unsigned int D.7367;
  char * current.18;
  _Bool D.7371;
  _Bool D.7372;
  _Bool D.7373;
  long unsigned int my_current.19;
  long unsigned int D.7377;
  struct bottom_index * D.7378;
  long unsigned int D.7379;
  long unsigned int D.7380;
  long unsigned int my_hhdr.20;
  struct hdr * GC_invalid_header.21;
  int my_current.22;
  map_entry_type * D.7386;
  sizetype displ.23;
  map_entry_type * D.7388;
  unsigned char D.7389;
  long unsigned int displ.24;
  long unsigned int D.7395;
  long unsigned int D.7396;
  long unsigned int D.7397;
  int GC_all_interior_pointers.25;
  int D.7409;
  sizetype D.7410;
  int D.7411;
  long unsigned int D.7412;
  long unsigned int D.7414;
  unsigned int displ.26;
  unsigned int D.7421;
  sizetype my_current.27;
  sizetype D.7423;
  sizetype D.7424;
  GC_word * D.7425;
  int D.7426;
  GC_word * D.7431;
  long unsigned int D.7432;
  long unsigned int D.7433;
  int GC_typed_mark_proc_index.28;
  long unsigned int GC_typed_mark_proc_index.29;
  long unsigned int D.7436;
  long unsigned int D.7437;
  long unsigned int D.7438;
  struct mse * D.7439;
  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.7365 = env * 8;
  D.7366 = GC_ext_descriptors.17 + D.7365;
  bm = D.7366->ed_bitmap;
  current_p = addr;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  goto <D.7138>;
  <D.7137>:
  D.7367 = bm & 1;
  if (D.7367 != 0) goto <D.7368>; else goto <D.7369>;
  <D.7368>:
  current = *current_p;
  current.18 = (char *) current;
  D.7371 = current.18 >= least_ha;
  current.18 = (char *) current;
  D.7372 = current.18 <= greatest_ha;
  D.7373 = D.7371 & D.7372;
  if (D.7373 != 0) goto <D.7374>; else goto <D.7375>;
  <D.7374>:
  {
    struct hdr * my_hhdr;
    char * my_current;

    my_current = (char *) current;
    my_current.19 = (long unsigned int) my_current;
    D.7377 = my_current.19 >> 22;
    D.7378 = GC_arrays._top_index[D.7377];
    my_current.19 = (long unsigned int) my_current;
    D.7379 = my_current.19 >> 12;
    D.7380 = D.7379 & 1023;
    my_hhdr = D.7378->index[D.7380];
    my_hhdr.20 = (long unsigned int) my_hhdr;
    if (my_hhdr.20 <= 4095) goto <D.7382>; else goto <D.7383>;
    <D.7382>:
    {
      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.7383>:
    {
      int displ;
      int map_entry;

      my_current.22 = (int) my_current;
      displ = my_current.22 & 4095;
      D.7386 = my_hhdr->hb_map;
      displ.23 = (sizetype) displ;
      D.7388 = D.7386 + displ.23;
      D.7389 = *D.7388;
      map_entry = (int) D.7389;
      displ = displ >> 2;
      if (map_entry > 253) goto <D.7390>; else goto <D.7391>;
      <D.7390>:
      if (map_entry == 254) goto <D.7392>; else goto <D.7393>;
      <D.7392>:
      displ.24 = (long unsigned int) displ;
      D.7395 = my_hhdr->hb_sz;
      D.7396 = displ.24 % D.7395;
      map_entry = (int) D.7396;
      displ = displ - map_entry;
      D.7395 = my_hhdr->hb_sz;
      displ.24 = (long unsigned int) displ;
      D.7397 = D.7395 + displ.24;
      if (D.7397 > 1024) goto <D.7398>; else goto <D.7399>;
      <D.7398>:
      GC_all_interior_pointers.25 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.25 != 0) goto <D.7401>; else goto <D.7402>;
      <D.7401>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.19);
      goto <D.7403>;
      <D.7402>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.19);
      <D.7403>:
      goto exit1;
      <D.7399>:
      goto <D.7404>;
      <D.7393>:
      GC_all_interior_pointers.25 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.25 != 0) goto <D.7405>; else goto <D.7406>;
      <D.7405>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.19);
      goto <D.7407>;
      <D.7406>:
      my_current.19 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.19);
      <D.7407>:
      goto exit1;
      <D.7404>:
      goto <D.7408>;
      <D.7391>:
      displ = displ - map_entry;
      <D.7408>:
      {
        register word * mark_word_addr;

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

          old = *mark_word_addr;
          D.7411 = displ & 31;
          my_bits = 1 << D.7411;
          D.7412 = old & my_bits;
          if (D.7412 != 0) goto exit1; else goto <D.7413>;
          <D.7413>:
          D.7414 = old | my_bits;
          *mark_word_addr = D.7414;
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.7415>; else goto <D.7416>;
        <D.7415>:
        goto <D.7417>;
        <D.7416>:
        mark_stack_ptr = mark_stack_ptr + 8;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.7418>; else goto <D.7419>;
        <D.7418>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.7419>:
        displ.26 = (unsigned int) displ;
        D.7421 = displ.26 * 4;
        my_current.27 = (sizetype) my_current;
        D.7423 = my_current.27 & 4294963200;
        D.7424 = D.7421 + D.7423;
        D.7425 = (GC_word *) D.7424;
        mark_stack_ptr->mse_start = D.7425;
        mark_stack_ptr->mse_descr = _descr;
        <D.7417>:
      }
    }
    exit1:
  }
  <D.7375>:
  <D.7369>:
  bm = bm >> 1;
  current_p = current_p + 4;
  <D.7138>:
  if (bm != 0) goto <D.7137>; else goto <D.7139>;
  <D.7139>:
  GC_ext_descriptors.17 = GC_ext_descriptors;
  D.7365 = env * 8;
  D.7366 = GC_ext_descriptors.17 + D.7365;
  D.7426 = D.7366->ed_continued;
  if (D.7426 != 0) goto <D.7427>; else goto <D.7428>;
  <D.7427>:
  mark_stack_ptr = mark_stack_ptr + 8;
  if (mark_stack_ptr >= mark_stack_limit) goto <D.7429>; else goto <D.7430>;
  <D.7429>:
  mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
  <D.7430>:
  D.7431 = addr + 128;
  mark_stack_ptr->mse_start = D.7431;
  D.7432 = env + 1;
  D.7433 = D.7432 << 6;
  GC_typed_mark_proc_index.28 = GC_typed_mark_proc_index;
  GC_typed_mark_proc_index.29 = (long unsigned int) GC_typed_mark_proc_index.28;
  D.7436 = D.7433 | GC_typed_mark_proc_index.29;
  D.7437 = D.7436 << 2;
  D.7438 = D.7437 | 2;
  mark_stack_ptr->mse_descr = D.7438;
  <D.7428>:
  D.7439 = mark_stack_ptr;
  return D.7439;
}


GC_descr_obj_size (union complex_descriptor * d)
{
  long unsigned int D.7441;
  word D.7442;
  long unsigned int D.7443;
  long unsigned int D.7444;
  long unsigned int D.7445;
  union ComplexDescriptor * D.7446;
  long unsigned int D.7447;
  union ComplexDescriptor * D.7448;
  long unsigned int D.7449;
  union ComplexDescriptor * D.7450;
  long unsigned int D.7451;

  D.7441 = d->ld.ld_tag;
  switch (D.7441) <default: <D.7146>, case 1: <D.7143>, case 2: <D.7144>, case 3: <D.7145>>
  <D.7143>:
  D.7443 = d->ld.ld_nelements;
  D.7444 = d->ld.ld_size;
  D.7442 = D.7443 * D.7444;
  return D.7442;
  <D.7144>:
  D.7445 = d->ad.ad_nelements;
  D.7446 = d->ad.ad_element_descr;
  D.7447 = GC_descr_obj_size (D.7446);
  D.7442 = D.7445 * D.7447;
  return D.7442;
  <D.7145>:
  D.7448 = d->sd.sd_first;
  D.7449 = GC_descr_obj_size (D.7448);
  D.7450 = d->sd.sd_second;
  D.7451 = GC_descr_obj_size (D.7450);
  D.7442 = D.7449 + D.7451;
  return D.7442;
  <D.7146>:
  GC_abort ("Bad complex descriptor");
  D.7442 = 0;
  return D.7442;
}


GC_push_complex_descriptor (word * addr, union complex_descriptor * d, struct mse * msp, struct mse * msl)
{
  long unsigned int D.7453;
  int msl.30;
  int msp.31;
  int D.7456;
  int D.7457;
  int nelements.32;
  struct mse * D.7461;
  union ComplexDescriptor * D.7464;
  union ComplexDescriptor * D.7467;
  register char * current;
  register word nelements;
  register word sz;
  register word i;

  current = addr;
  D.7453 = d->ld.ld_tag;
  switch (D.7453) <default: <D.7168>, case 1: <D.7157>, case 2: <D.7162>, case 3: <D.7167>>
  <D.7157>:
  {
    register GC_descr descr;

    descr = d->ld.ld_descriptor;
    nelements = d->ld.ld_nelements;
    msl.30 = (int) msl;
    msp.31 = (int) msp;
    D.7456 = msl.30 - msp.31;
    D.7457 = D.7456 /[ex] 8;
    nelements.32 = (int) nelements;
    if (D.7457 <= nelements.32) goto <D.7459>; else goto <D.7460>;
    <D.7459>:
    D.7461 = 0B;
    return D.7461;
    <D.7460>:
    sz = d->ld.ld_size;
    i = 0;
    goto <D.7160>;
    <D.7159>:
    msp = msp + 8;
    msp->mse_start = current;
    msp->mse_descr = descr;
    current = current + sz;
    i = i + 1;
    <D.7160>:
    if (i < nelements) goto <D.7159>; else goto <D.7161>;
    <D.7161>:
    D.7461 = msp;
    return D.7461;
  }
  <D.7162>:
  {
    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.7165>;
    <D.7164>:
    msp = GC_push_complex_descriptor (current, descr, msp, msl);
    if (msp == 0B) goto <D.7462>; else goto <D.7463>;
    <D.7462>:
    D.7461 = 0B;
    return D.7461;
    <D.7463>:
    current = current + sz;
    i = i + 1;
    <D.7165>:
    if (i < nelements) goto <D.7164>; else goto <D.7166>;
    <D.7166>:
    D.7461 = msp;
    return D.7461;
  }
  <D.7167>:
  D.7464 = d->sd.sd_first;
  sz = GC_descr_obj_size (D.7464);
  D.7464 = d->sd.sd_first;
  msp = GC_push_complex_descriptor (current, D.7464, msp, msl);
  if (msp == 0B) goto <D.7465>; else goto <D.7466>;
  <D.7465>:
  D.7461 = 0B;
  return D.7461;
  <D.7466>:
  current = current + sz;
  D.7467 = d->sd.sd_second;
  msp = GC_push_complex_descriptor (current, D.7467, msp, msl);
  D.7461 = msp;
  return D.7461;
  <D.7168>:
  GC_abort ("Bad complex descriptor");
  D.7461 = 0B;
  return D.7461;
}


GC_array_mark_proc (word * addr, struct mse * mark_stack_ptr, struct mse * mark_stack_limit, word env)
{
  long unsigned int addr.33;
  long unsigned int D.7470;
  struct bottom_index * D.7471;
  long unsigned int D.7472;
  long unsigned int D.7473;
  sizetype D.7474;
  sizetype D.7475;
  word * D.7476;
  long unsigned int D.7477;
  struct mse * D.7480;
  struct mse * D.7481;
  long unsigned int D.7484;
  register struct hdr * hhdr;
  register word sz;
  register union complex_descriptor * descr;
  struct mse * orig_mark_stack_ptr;
  struct mse * new_mark_stack_ptr;

  addr.33 = (long unsigned int) addr;
  D.7470 = addr.33 >> 22;
  D.7471 = GC_arrays._top_index[D.7470];
  addr.33 = (long unsigned int) addr;
  D.7472 = addr.33 >> 12;
  D.7473 = D.7472 & 1023;
  hhdr = D.7471->index[D.7473];
  sz = hhdr->hb_sz;
  D.7474 = sz + 1073741823;
  D.7475 = D.7474 * 4;
  D.7476 = addr + D.7475;
  D.7477 = *D.7476;
  descr = (union complex_descriptor *) D.7477;
  orig_mark_stack_ptr = mark_stack_ptr;
  if (descr == 0B) goto <D.7478>; else goto <D.7479>;
  <D.7478>:
  D.7480 = orig_mark_stack_ptr;
  return D.7480;
  <D.7479>:
  D.7481 = mark_stack_limit + 4294967288;
  new_mark_stack_ptr = GC_push_complex_descriptor (addr, descr, mark_stack_ptr, D.7481);
  if (new_mark_stack_ptr == 0B) goto <D.7482>; else goto <D.7483>;
  <D.7482>:
  GC_mark_stack_too_small = 1;
  new_mark_stack_ptr = orig_mark_stack_ptr + 8;
  new_mark_stack_ptr->mse_start = addr;
  D.7484 = sz << 2;
  new_mark_stack_ptr->mse_descr = D.7484;
  goto <D.7485>;
  <D.7483>:
  new_mark_stack_ptr = new_mark_stack_ptr + 8;
  D.7474 = sz + 1073741823;
  D.7475 = D.7474 * 4;
  D.7476 = addr + D.7475;
  new_mark_stack_ptr->mse_start = D.7476;
  new_mark_stack_ptr->mse_descr = 4;
  <D.7485>:
  D.7480 = new_mark_stack_ptr;
  return D.7480;
}


GC_make_descriptor (GC_word * bm, size_t len)
{
  unsigned int D.7487;
  int GC_explicit_typing_initialized.34;
  long unsigned int last_set_bit.35;
  long unsigned int D.7493;
  long unsigned int D.7494;
  GC_word * D.7495;
  long unsigned int D.7496;
  int D.7497;
  long unsigned int D.7498;
  long unsigned int D.7499;
  GC_descr D.7502;
  unsigned int i.36;
  unsigned int D.7504;
  unsigned int D.7505;
  GC_word * D.7506;
  long unsigned int D.7507;
  int D.7508;
  long unsigned int D.7509;
  long unsigned int D.7510;
  long int D.7515;
  long int D.7516;
  long unsigned int D.7521;
  long unsigned int index.37;
  long unsigned int D.7525;
  int GC_typed_mark_proc_index.38;
  long unsigned int GC_typed_mark_proc_index.39;
  long unsigned int D.7528;
  long unsigned int D.7529;
  register signed_word last_set_bit;
  register word result;
  register int i;

  D.7487 = len + 4294967295;
  last_set_bit = (signed_word) D.7487;
  GC_explicit_typing_initialized.34 = GC_explicit_typing_initialized;
  if (GC_explicit_typing_initialized.34 == 0) goto <D.7489>; else goto <D.7490>;
  <D.7489>:
  GC_init_explicit_typing ();
  <D.7490>:
  goto <D.7188>;
  <D.7187>:
  last_set_bit = last_set_bit + -1;
  <D.7188>:
  if (last_set_bit >= 0) goto <D.7491>; else goto <D.7189>;
  <D.7491>:
  last_set_bit.35 = (long unsigned int) last_set_bit;
  D.7493 = last_set_bit.35 / 32;
  D.7494 = D.7493 * 4;
  D.7495 = bm + D.7494;
  D.7496 = *D.7495;
  D.7497 = last_set_bit & 31;
  D.7498 = D.7496 >> D.7497;
  D.7499 = D.7498 & 1;
  if (D.7499 == 0) goto <D.7187>; else goto <D.7189>;
  <D.7189>:
  if (last_set_bit < 0) goto <D.7500>; else goto <D.7501>;
  <D.7500>:
  D.7502 = 0;
  return D.7502;
  <D.7501>:
  {
    register GC_bool all_bits_set;

    all_bits_set = 1;
    i = 0;
    goto <D.7193>;
    <D.7192>:
    i.36 = (unsigned int) i;
    D.7504 = i.36 / 32;
    D.7505 = D.7504 * 4;
    D.7506 = bm + D.7505;
    D.7507 = *D.7506;
    D.7508 = i & 31;
    D.7509 = D.7507 >> D.7508;
    D.7510 = D.7509 & 1;
    if (D.7510 == 0) goto <D.7511>; else goto <D.7512>;
    <D.7511>:
    all_bits_set = 0;
    goto <D.7191>;
    <D.7512>:
    i = i + 1;
    <D.7193>:
    if (i < last_set_bit) goto <D.7192>; else goto <D.7191>;
    <D.7191>:
    if (all_bits_set != 0) goto <D.7513>; else goto <D.7514>;
    <D.7513>:
    D.7515 = last_set_bit + 1;
    D.7516 = D.7515 << 2;
    D.7502 = (GC_descr) D.7516;
    return D.7502;
    <D.7514>:
  }
  last_set_bit.35 = (long unsigned int) last_set_bit;
  if (last_set_bit.35 <= 29) goto <D.7517>; else goto <D.7518>;
  <D.7517>:
  result = 2147483648;
  i = last_set_bit + -1;
  goto <D.7195>;
  <D.7194>:
  result = result >> 1;
  i.36 = (unsigned int) i;
  D.7504 = i.36 / 32;
  D.7505 = D.7504 * 4;
  D.7506 = bm + D.7505;
  D.7507 = *D.7506;
  D.7508 = i & 31;
  D.7509 = D.7507 >> D.7508;
  D.7510 = D.7509 & 1;
  if (D.7510 != 0) goto <D.7519>; else goto <D.7520>;
  <D.7519>:
  result = result | 2147483648;
  <D.7520>:
  i = i + -1;
  <D.7195>:
  if (i >= 0) goto <D.7194>; else goto <D.7196>;
  <D.7196>:
  result = result | 1;
  D.7502 = result;
  return D.7502;
  <D.7518>:
  {
    signed_word index;

    last_set_bit.35 = (long unsigned int) last_set_bit;
    D.7521 = last_set_bit.35 + 1;
    index = GC_add_ext_descriptor (bm, D.7521);
    if (index == -1) goto <D.7522>; else goto <D.7523>;
    <D.7522>:
    D.7515 = last_set_bit + 1;
    D.7516 = D.7515 << 2;
    D.7502 = (GC_descr) D.7516;
    return D.7502;
    <D.7523>:
    index.37 = (long unsigned int) index;
    D.7525 = index.37 << 6;
    GC_typed_mark_proc_index.38 = GC_typed_mark_proc_index;
    GC_typed_mark_proc_index.39 = (long unsigned int) GC_typed_mark_proc_index.38;
    D.7528 = D.7525 | GC_typed_mark_proc_index.39;
    D.7529 = D.7528 << 2;
    result = D.7529 | 2;
    D.7502 = result;
    return D.7502;
  }
}


GC_malloc_explicitly_typed (size_t lb, GC_descr d)
{
  int GC_all_interior_pointers.40;
  unsigned int GC_all_interior_pointers.41;
  unsigned int D.7533;
  long unsigned int GC_all_interior_pointers.42;
  long unsigned int D.7535;
  char * * GC_eobjfreelist.43;
  long unsigned int D.7539;
  int D.7540;
  int GC_explicit_kind.44;
  char * D.7546;
  void * D.7549;
  char * D.7551;
  long unsigned int D.7552;
  long unsigned int D.7553;
  char * D.7555;
  unsigned int D.7558;
  sizetype D.7561;
  sizetype D.7562;
  word * D.7563;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.40 = GC_all_interior_pointers;
  GC_all_interior_pointers.41 = (unsigned int) GC_all_interior_pointers.40;
  D.7533 = lb - GC_all_interior_pointers.41;
  lb = D.7533 + 4;
  GC_all_interior_pointers.40 = GC_all_interior_pointers;
  GC_all_interior_pointers.42 = (long unsigned int) GC_all_interior_pointers.40;
  D.7535 = 2048 - GC_all_interior_pointers.42;
  if (D.7535 >= lb) goto <D.7536>; else goto <D.7537>;
  <D.7536>:
  lw = GC_arrays._size_map[lb];
  GC_eobjfreelist.43 = GC_eobjfreelist;
  D.7539 = lw * 4;
  opp = GC_eobjfreelist.43 + D.7539;
  D.7540 = GC_test_and_set (&GC_allocate_lock);
  if (D.7540 != 0) goto <D.7541>; else goto <D.7542>;
  <D.7541>:
  GC_lock ();
  <D.7542>:
  op = *opp;
  if (op == 0B) goto <D.7543>; else goto <D.7544>;
  <D.7543>:
  GC_clear (&GC_allocate_lock);
  GC_explicit_kind.44 = GC_explicit_kind;
  D.7546 = GC_generic_malloc (lb, GC_explicit_kind.44);
  op = GC_clear_stack (D.7546);
  if (op == 0B) goto <D.7547>; else goto <D.7548>;
  <D.7547>:
  D.7549 = 0B;
  return D.7549;
  <D.7548>:
  lw = GC_arrays._size_map[lb];
  goto <D.7550>;
  <D.7544>:
  D.7551 = MEM[(char * *)op];
  *opp = D.7551;
  MEM[(char * *)op] = 0B;
  D.7552 = GC_arrays._words_allocd;
  D.7553 = D.7552 + lw;
  GC_arrays._words_allocd = D.7553;
  GC_clear (&GC_allocate_lock);
  <D.7550>:
  goto <D.7554>;
  <D.7537>:
  GC_explicit_kind.44 = GC_explicit_kind;
  D.7555 = GC_generic_malloc (lb, GC_explicit_kind.44);
  op = GC_clear_stack (D.7555);
  if (op != 0B) goto <D.7556>; else goto <D.7557>;
  <D.7556>:
  D.7558 = GC_size (op);
  lw = D.7558 >> 2;
  <D.7557>:
  <D.7554>:
  if (op != 0B) goto <D.7559>; else goto <D.7560>;
  <D.7559>:
  D.7561 = lw + 1073741823;
  D.7562 = D.7561 * 4;
  D.7563 = op + D.7562;
  *D.7563 = d;
  <D.7560>:
  D.7549 = op;
  return D.7549;
}


GC_malloc_explicitly_typed_ignore_off_page (size_t lb, GC_descr d)
{
  int GC_all_interior_pointers.45;
  unsigned int GC_all_interior_pointers.46;
  unsigned int D.7567;
  long unsigned int GC_all_interior_pointers.47;
  long unsigned int D.7569;
  char * * GC_eobjfreelist.48;
  long unsigned int D.7573;
  int D.7574;
  int GC_explicit_kind.49;
  char * D.7580;
  char * D.7582;
  long unsigned int D.7583;
  long unsigned int D.7584;
  char * D.7586;
  unsigned int D.7589;
  sizetype D.7592;
  sizetype D.7593;
  word * D.7594;
  void * D.7595;
  register char * op;
  register char * * opp;
  register word lw;

  GC_all_interior_pointers.45 = GC_all_interior_pointers;
  GC_all_interior_pointers.46 = (unsigned int) GC_all_interior_pointers.45;
  D.7567 = lb - GC_all_interior_pointers.46;
  lb = D.7567 + 4;
  GC_all_interior_pointers.45 = GC_all_interior_pointers;
  GC_all_interior_pointers.47 = (long unsigned int) GC_all_interior_pointers.45;
  D.7569 = 2048 - GC_all_interior_pointers.47;
  if (D.7569 >= lb) goto <D.7570>; else goto <D.7571>;
  <D.7570>:
  lw = GC_arrays._size_map[lb];
  GC_eobjfreelist.48 = GC_eobjfreelist;
  D.7573 = lw * 4;
  opp = GC_eobjfreelist.48 + D.7573;
  D.7574 = GC_test_and_set (&GC_allocate_lock);
  if (D.7574 != 0) goto <D.7575>; else goto <D.7576>;
  <D.7575>:
  GC_lock ();
  <D.7576>:
  op = *opp;
  if (op == 0B) goto <D.7577>; else goto <D.7578>;
  <D.7577>:
  GC_clear (&GC_allocate_lock);
  GC_explicit_kind.49 = GC_explicit_kind;
  D.7580 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.49);
  op = GC_clear_stack (D.7580);
  lw = GC_arrays._size_map[lb];
  goto <D.7581>;
  <D.7578>:
  D.7582 = MEM[(char * *)op];
  *opp = D.7582;
  MEM[(char * *)op] = 0B;
  D.7583 = GC_arrays._words_allocd;
  D.7584 = D.7583 + lw;
  GC_arrays._words_allocd = D.7584;
  GC_clear (&GC_allocate_lock);
  <D.7581>:
  goto <D.7585>;
  <D.7571>:
  GC_explicit_kind.49 = GC_explicit_kind;
  D.7586 = GC_generic_malloc_ignore_off_page (lb, GC_explicit_kind.49);
  op = GC_clear_stack (D.7586);
  if (op != 0B) goto <D.7587>; else goto <D.7588>;
  <D.7587>:
  D.7589 = GC_size (op);
  lw = D.7589 >> 2;
  <D.7588>:
  <D.7585>:
  if (op != 0B) goto <D.7590>; else goto <D.7591>;
  <D.7590>:
  D.7592 = lw + 1073741823;
  D.7593 = D.7592 * 4;
  D.7594 = op + D.7593;
  *D.7594 = d;
  <D.7591>:
  D.7595 = op;
  return D.7595;
}


GC_calloc_explicitly_typed (size_t n, size_t lb, GC_descr d)
{
  void * D.7597;
  unsigned int D.7598;
  long unsigned int simple_descr.50;
  int GC_all_interior_pointers.51;
  unsigned int GC_all_interior_pointers.52;
  unsigned int D.7602;
  long unsigned int GC_all_interior_pointers.53;
  long unsigned int D.7605;
  char * * GC_arobjfreelist.54;
  long unsigned int D.7609;
  int D.7610;
  int GC_array_kind.55;
  char * D.7616;
  char * D.7620;
  long unsigned int D.7621;
  long unsigned int D.7622;
  char * D.7624;
  unsigned int D.7627;
  sizetype D.7630;
  sizetype D.7631;
  long unsigned int D.7632;
  long unsigned int D.7633;
  long unsigned int D.7634;
  sizetype D.7635;
  sizetype D.7636;
  volatile word * D.7637;
  long unsigned int lp.56;
  word * D.7640;
  union complex_descriptor * complex_descr.57;
  long unsigned int complex_descr.58;
  void * * D.7643;
  unsigned int GC_finalization_failures.59;
  register char * op;
  register char * * opp;
  register word lw;
  GC_descr simple_descr;
  union complex_descriptor * complex_descr;
  register int descr_type;
  struct LeafDescriptor leaf;

  try
    {
      descr_type = GC_make_array_descriptor (n, lb, d, &simple_descr, &complex_descr, &leaf);
      switch (descr_type) <default: <D.7603>, case -1: <D.7225>, case 0: <D.7226>, case 1: <D.7227>, case 2: <D.7229>>
      <D.7225>:
      D.7597 = 0B;
      return D.7597;
      <D.7226>:
      D.7598 = n * lb;
      simple_descr.50 = simple_descr;
      D.7597 = GC_malloc_explicitly_typed (D.7598, simple_descr.50);
      return D.7597;
      <D.7227>:
      lb = lb * n;
      GC_all_interior_pointers.51 = GC_all_interior_pointers;
      GC_all_interior_pointers.52 = (unsigned int) GC_all_interior_pointers.51;
      D.7602 = lb - GC_all_interior_pointers.52;
      lb = D.7602 + 20;
      goto <D.7228>;
      <D.7229>:
      lb = lb * n;
      GC_all_interior_pointers.51 = GC_all_interior_pointers;
      GC_all_interior_pointers.52 = (unsigned int) GC_all_interior_pointers.51;
      D.7602 = lb - GC_all_interior_pointers.52;
      lb = D.7602 + 4;
      goto <D.7228>;
      <D.7603>:
      <D.7228>:
      GC_all_interior_pointers.51 = GC_all_interior_pointers;
      GC_all_interior_pointers.53 = (long unsigned int) GC_all_interior_pointers.51;
      D.7605 = 2048 - GC_all_interior_pointers.53;
      if (D.7605 >= lb) goto <D.7606>; else goto <D.7607>;
      <D.7606>:
      lw = GC_arrays._size_map[lb];
      GC_arobjfreelist.54 = GC_arobjfreelist;
      D.7609 = lw * 4;
      opp = GC_arobjfreelist.54 + D.7609;
      D.7610 = GC_test_and_set (&GC_allocate_lock);
      if (D.7610 != 0) goto <D.7611>; else goto <D.7612>;
      <D.7611>:
      GC_lock ();
      <D.7612>:
      op = *opp;
      if (op == 0B) goto <D.7613>; else goto <D.7614>;
      <D.7613>:
      GC_clear (&GC_allocate_lock);
      GC_array_kind.55 = GC_array_kind;
      D.7616 = GC_generic_malloc (lb, GC_array_kind.55);
      op = GC_clear_stack (D.7616);
      if (op == 0B) goto <D.7617>; else goto <D.7618>;
      <D.7617>:
      D.7597 = 0B;
      return D.7597;
      <D.7618>:
      lw = GC_arrays._size_map[lb];
      goto <D.7619>;
      <D.7614>:
      D.7620 = MEM[(char * *)op];
      *opp = D.7620;
      MEM[(char * *)op] = 0B;
      D.7621 = GC_arrays._words_allocd;
      D.7622 = D.7621 + lw;
      GC_arrays._words_allocd = D.7622;
      GC_clear (&GC_allocate_lock);
      <D.7619>:
      goto <D.7623>;
      <D.7607>:
      GC_array_kind.55 = GC_array_kind;
      D.7624 = GC_generic_malloc (lb, GC_array_kind.55);
      op = GC_clear_stack (D.7624);
      if (op == 0B) goto <D.7625>; else goto <D.7626>;
      <D.7625>:
      D.7597 = 0B;
      return D.7597;
      <D.7626>:
      D.7627 = GC_size (op);
      lw = D.7627 >> 2;
      <D.7623>:
      if (descr_type == 1) goto <D.7628>; else goto <D.7629>;
      <D.7628>:
      {
        volatile struct LeafDescriptor * lp;

        D.7630 = lw + 1073741819;
        D.7631 = D.7630 * 4;
        lp = op + D.7631;
        lp->ld_tag = 1;
        D.7632 = leaf.ld_size;
        lp->ld_size = D.7632;
        D.7633 = leaf.ld_nelements;
        lp->ld_nelements = D.7633;
        D.7634 = leaf.ld_descriptor;
        lp->ld_descriptor = D.7634;
        D.7635 = lw + 1073741823;
        D.7636 = D.7635 * 4;
        D.7637 = op + D.7636;
        lp.56 = (long unsigned int) lp;
        *D.7637 = lp.56;
      }
      goto <D.7639>;
      <D.7629>:
      {
        extern unsigned int GC_finalization_failures;
        unsigned int ff;

        ff = GC_finalization_failures;
        D.7635 = lw + 1073741823;
        D.7636 = D.7635 * 4;
        D.7640 = op + D.7636;
        complex_descr.57 = complex_descr;
        complex_descr.58 = (long unsigned int) complex_descr.57;
        *D.7640 = complex_descr.58;
        D.7635 = lw + 1073741823;
        D.7636 = D.7635 * 4;
        D.7643 = op + D.7636;
        GC_general_register_disappearing_link (D.7643, op);
        GC_finalization_failures.59 = GC_finalization_failures;
        if (ff != GC_finalization_failures.59) goto <D.7645>; else goto <D.7646>;
        <D.7645>:
        D.7598 = n * lb;
        D.7597 = GC_malloc (D.7598);
        return D.7597;
        <D.7646>:
      }
      <D.7639>:
      D.7597 = op;
      return D.7597;
    }
  finally
    {
      simple_descr = {CLOBBER};
      complex_descr = {CLOBBER};
      leaf = {CLOBBER};
    }
}